import org.junit.FixMethodOrder;
import org.junit.Test;
import org.junit.runners.MethodSorters;

@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class PerimeterRegressionTest0 {

    public static boolean debug = false;

    @Test
    public void test0001() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0001");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (-1L), (float) (-1L));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.0f) + "'", float2 == (-4.0f));
    }

    @Test
    public void test0002() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0002");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (float) (short) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-52.0f) + "'", float2 == (-52.0f));
    }

    @Test
    public void test0003() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0003");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (float) (short) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0004() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0004");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (float) (-1L));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-52.0f) + "'", float2 == (-52.0f));
    }

    @Test
    public void test0005() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0005");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.0f + "'", float2 == 2.0f);
    }

    @Test
    public void test0006() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0006");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) '4');
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 326.7256359733385d + "'", double1 == 326.7256359733385d);
    }

    @Test
    public void test0007() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0007");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 10L);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 62.83185307179586d + "'", double1 == 62.83185307179586d);
    }

    @Test
    public void test0008() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0008");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (byte) 10);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 62.83185307179586d + "'", double1 == 62.83185307179586d);
    }

    @Test
    public void test0009() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0009");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((float) ' ', (-4.0f), (-52.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0010() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0010");
        double double1 = org.example.maths.Perimeter.perimeterCircle(0.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 0.0d + "'", double1 == 0.0d);
    }

    @Test
    public void test0011() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0011");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (-1));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6.283185307179586d) + "'", double1 == (-6.283185307179586d));
    }

    @Test
    public void test0012() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0012");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) ' ');
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 201.06192982974676d + "'", double1 == 201.06192982974676d);
    }

    @Test
    public void test0013() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0013");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((float) '4', (float) 0, (float) 1L, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0014() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0014");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(17.0f, (float) 0L, (-52.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0015() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0015");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(17.0f, (float) (byte) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 32.0f + "'", float2 == 32.0f);
    }

    @Test
    public void test0016() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0016");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (float) '4');
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5044.0f + "'", float2 == 5044.0f);
    }

    @Test
    public void test0017() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0017");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (-1), (-52.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-106.0f) + "'", float2 == (-106.0f));
    }

    @Test
    public void test0018() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0018");
        double double1 = org.example.maths.Perimeter.perimeterCircle(400.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2513.2741228718346d + "'", double1 == 2513.2741228718346d);
    }

    @Test
    public void test0019() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0019");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-52.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-326.7256359733385d) + "'", double1 == (-326.7256359733385d));
    }

    @Test
    public void test0020() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0020");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.0f), 400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 798.0f + "'", float2 == 798.0f);
    }

    @Test
    public void test0021() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0021");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 'a', (float) 10L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 214.0f + "'", float2 == 214.0f);
    }

    @Test
    public void test0022() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0022");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(400.0f, (float) (-1));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 798.0f + "'", float2 == 798.0f);
    }

    @Test
    public void test0023() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0023");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (float) (short) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20.0f + "'", float2 == 20.0f);
    }

    @Test
    public void test0024() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0024");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 10.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 100.0f + "'", float2 == 100.0f);
    }

    @Test
    public void test0025() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0025");
        java.lang.Object obj0 = new java.lang.Object();
        java.lang.Class<?> wildcardClass1 = obj0.getClass();
        org.junit.Assert.assertNotNull(wildcardClass1);
    }

    @Test
    public void test0026() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0026");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 12.566370614359172d + "'", double1 == 12.566370614359172d);
    }

    @Test
    public void test0027() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0027");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (float) '#');
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0028() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0028");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (short) -1);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6.283185307179586d) + "'", double1 == (-6.283185307179586d));
    }

    @Test
    public void test0029() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0029");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(400.0f, 214.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1228.0f + "'", float2 == 1228.0f);
    }

    @Test
    public void test0030() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0030");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 10, (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 220.0f + "'", float2 == 220.0f);
    }

    @Test
    public void test0031() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0031");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (byte) 1);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.283185307179586d + "'", double1 == 6.283185307179586d);
    }

    @Test
    public void test0032() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0032");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (float) (short) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0033() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0033");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (byte) 0);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 0.0d + "'", double1 == 0.0d);
    }

    @Test
    public void test0034() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0034");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) '#', (float) (-1L));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 68.0f + "'", float2 == 68.0f);
    }

    @Test
    public void test0035() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0035");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 1);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.283185307179586d + "'", double1 == 6.283185307179586d);
    }

    @Test
    public void test0036() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0036");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (float) (byte) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10.0f) + "'", float2 == (-10.0f));
    }

    @Test
    public void test0037() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0037");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1352.0f + "'", float2 == 1352.0f);
    }

    @Test
    public void test0038() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0038");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 0, (-44.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-88.0f) + "'", float2 == (-88.0f));
    }

    @Test
    public void test0039() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0039");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 100.0f + "'", float2 == 100.0f);
    }

    @Test
    public void test0040() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0040");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (float) (byte) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0041() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0041");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (short) 10);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 62.83185307179586d + "'", double1 == 62.83185307179586d);
    }

    @Test
    public void test0042() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0042");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-10.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test0043() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0043");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 135.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4320.0f + "'", float2 == 4320.0f);
    }

    @Test
    public void test0044() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0044");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (float) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9700.0f + "'", float2 == 9700.0f);
    }

    @Test
    public void test0045() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0045");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (float) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 10.0f + "'", float2 == 10.0f);
    }

    @Test
    public void test0046() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0046");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 1, (float) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 202.0f + "'", float2 == 202.0f);
    }

    @Test
    public void test0047() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0047");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-52.0f), 1228.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2352.0f + "'", float2 == 2352.0f);
    }

    @Test
    public void test0048() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0048");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 214.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 21400.0f + "'", float2 == 21400.0f);
    }

    @Test
    public void test0049() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0049");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2352.0f, (float) 10L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4724.0f + "'", float2 == 4724.0f);
    }

    @Test
    public void test0050() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0050");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(66.0f, 21400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42932.0f + "'", float2 == 42932.0f);
    }

    @Test
    public void test0051() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0051");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (float) (short) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0052() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0052");
        double double1 = org.example.maths.Perimeter.perimeterCircle(901.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5661.149961768807d + "'", double1 == 5661.149961768807d);
    }

    @Test
    public void test0053() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0053");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (float) (short) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-97.0f) + "'", float2 == (-97.0f));
    }

    @Test
    public void test0054() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0054");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-66.0f), (float) 100L, 2.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0055() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0055");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (short) 100);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 628.3185307179587d + "'", double1 == 628.3185307179587d);
    }

    @Test
    public void test0056() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0056");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 1L, 16.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 34.0f + "'", float2 == 34.0f);
    }

    @Test
    public void test0057() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0057");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (float) (byte) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10.0f) + "'", float2 == (-10.0f));
    }

    @Test
    public void test0058() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0058");
        double double1 = org.example.maths.Perimeter.perimeterCircle(798.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5013.98187512931d + "'", double1 == 5013.98187512931d);
    }

    @Test
    public void test0059() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0059");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.283185307179586d + "'", double1 == 6.283185307179586d);
    }

    @Test
    public void test0060() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0060");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 0, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0061() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0061");
        double double1 = org.example.maths.Perimeter.perimeterCircle(21400.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 134460.16557364314d + "'", double1 == 134460.16557364314d);
    }

    @Test
    public void test0062() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0062");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2352.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 14778.051842486388d + "'", double1 == 14778.051842486388d);
    }

    @Test
    public void test0063() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0063");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-69.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-433.53978619539146d) + "'", double1 == (-433.53978619539146d));
    }

    @Test
    public void test0064() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0064");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 18.84955592153876d + "'", double1 == 18.84955592153876d);
    }

    @Test
    public void test0065() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0065");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (float) (-1));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10.0f) + "'", float2 == (-10.0f));
    }

    @Test
    public void test0066() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0066");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(16.0f, (float) 100L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 232.0f + "'", float2 == 232.0f);
    }

    @Test
    public void test0067() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0067");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 'a');
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 609.4689747964198d + "'", double1 == 609.4689747964198d);
    }

    @Test
    public void test0068() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0068");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (-1L));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6.283185307179586d) + "'", double1 == (-6.283185307179586d));
    }

    @Test
    public void test0069() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0069");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 202.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2020.0f + "'", float2 == 2020.0f);
    }

    @Test
    public void test0070() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0070");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1102.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6924.070208511904d + "'", double1 == 6924.070208511904d);
    }

    @Test
    public void test0071() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0071");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 1L, 4675.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9352.0f + "'", float2 == 9352.0f);
    }

    @Test
    public void test0072() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0072");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 32.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1120.0f + "'", float2 == 1120.0f);
    }

    @Test
    public void test0073() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0073");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(26.0f, (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 252.0f + "'", float2 == 252.0f);
    }

    @Test
    public void test0074() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0074");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-88.0f), 21400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42624.0f + "'", float2 == 42624.0f);
    }

    @Test
    public void test0075() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0075");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1352.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8494.8665353068d + "'", double1 == 8494.8665353068d);
    }

    @Test
    public void test0076() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0076");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 10, (float) '#');
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 90.0f + "'", float2 == 90.0f);
    }

    @Test
    public void test0077() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0077");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-58.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3016.0f) + "'", float2 == (-3016.0f));
    }

    @Test
    public void test0078() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0078");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (float) 0L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0079() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0079");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(400.0f, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 852.0f + "'", float2 == 852.0f);
    }

    @Test
    public void test0080() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0080");
        double double1 = org.example.maths.Perimeter.perimeterCircle(46.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 289.02652413026095d + "'", double1 == 289.02652413026095d);
    }

    @Test
    public void test0081() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0081");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-84.0f), 5044.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9920.0f + "'", float2 == 9920.0f);
    }

    @Test
    public void test0082() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0082");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-100.0f), (float) (byte) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-198.0f) + "'", float2 == (-198.0f));
    }

    @Test
    public void test0083() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0083");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4675.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 29373.891311064566d + "'", double1 == 29373.891311064566d);
    }

    @Test
    public void test0084() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0084");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 4675.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0085() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0085");
        double double1 = org.example.maths.Perimeter.perimeterCircle(232.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1457.698991265664d + "'", double1 == 1457.698991265664d);
    }

    @Test
    public void test0086() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0086");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 9920.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9920.0f) + "'", float2 == (-9920.0f));
    }

    @Test
    public void test0087() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0087");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-97.0f), 78.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-38.0f) + "'", float2 == (-38.0f));
    }

    @Test
    public void test0088() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0088");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (float) 1L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.0f + "'", float2 == 1.0f);
    }

    @Test
    public void test0089() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0089");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 1102.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1102.0f) + "'", float2 == (-1102.0f));
    }

    @Test
    public void test0090() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0090");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-198.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-19800.0f) + "'", float2 == (-19800.0f));
    }

    @Test
    public void test0091() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0091");
        double double1 = org.example.maths.Perimeter.perimeterCircle(78.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 490.0884539600077d + "'", double1 == 490.0884539600077d);
    }

    @Test
    public void test0092() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0092");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(901.0f, 2352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6506.0f + "'", float2 == 6506.0f);
    }

    @Test
    public void test0093() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0093");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4724.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 29681.767391116366d + "'", double1 == 29681.767391116366d);
    }

    @Test
    public void test0094() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0094");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 0L);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 0.0d + "'", double1 == 0.0d);
    }

    @Test
    public void test0095() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0095");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1102.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6924.070208511904d) + "'", double1 == (-6924.070208511904d));
    }

    @Test
    public void test0096() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0096");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 51.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5100.0f + "'", float2 == 5100.0f);
    }

    @Test
    public void test0097() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0097");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 9700.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 504400.0f + "'", float2 == 504400.0f);
    }

    @Test
    public void test0098() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0098");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(852.0f, 1032.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3768.0f + "'", float2 == 3768.0f);
    }

    @Test
    public void test0099() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0099");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9920.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 62329.198247221495d + "'", double1 == 62329.198247221495d);
    }

    @Test
    public void test0100() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0100");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1120.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7037.167544041136d + "'", double1 == 7037.167544041136d);
    }

    @Test
    public void test0101() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0101");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6506.0f, (float) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 13012.0f + "'", float2 == 13012.0f);
    }

    @Test
    public void test0102() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0102");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 17.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 170.0f + "'", float2 == 170.0f);
    }

    @Test
    public void test0103() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0103");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-52.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 52.0f + "'", float2 == 52.0f);
    }

    @Test
    public void test0104() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0104");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0105() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0105");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-69.0f), 78.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 18.0f + "'", float2 == 18.0f);
    }

    @Test
    public void test0106() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0106");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (float) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.0f) + "'", float2 == (-1.0f));
    }

    @Test
    public void test0107() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0107");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((float) 0L, 18.0f, 718.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0108() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0108");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5100.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 32044.24506661589d + "'", double1 == 32044.24506661589d);
    }

    @Test
    public void test0109() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0109");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 9700.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9700.0f + "'", float2 == 9700.0f);
    }

    @Test
    public void test0110() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0110");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(10.0f, 718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1456.0f + "'", float2 == 1456.0f);
    }

    @Test
    public void test0111() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0111");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) '#', 51.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 172.0f + "'", float2 == 172.0f);
    }

    @Test
    public void test0112() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0112");
        double double1 = org.example.maths.Perimeter.perimeterCircle(34.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 213.62830044410595d + "'", double1 == 213.62830044410595d);
    }

    @Test
    public void test0113() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0113");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 10L, 1664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3348.0f + "'", float2 == 3348.0f);
    }

    @Test
    public void test0114() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0114");
        double double1 = org.example.maths.Perimeter.perimeterCircle(26.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 163.36281798666926d + "'", double1 == 163.36281798666926d);
    }

    @Test
    public void test0115() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0115");
        double double1 = org.example.maths.Perimeter.perimeterCircle(252.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1583.3626974092558d + "'", double1 == 1583.3626974092558d);
    }

    @Test
    public void test0116() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0116");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-58.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5626.0f) + "'", float2 == (-5626.0f));
    }

    @Test
    public void test0117() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0117");
        double double1 = org.example.maths.Perimeter.perimeterCircle(52.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 326.7256359733385d + "'", double1 == 326.7256359733385d);
    }

    @Test
    public void test0118() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0118");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-29.0f), 3348.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6638.0f + "'", float2 == 6638.0f);
    }

    @Test
    public void test0119() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0119");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-44.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-276.46015351590177d) + "'", double1 == (-276.46015351590177d));
    }

    @Test
    public void test0120() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0120");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 10L, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20.0f + "'", float2 == 20.0f);
    }

    @Test
    public void test0121() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0121");
        double double1 = org.example.maths.Perimeter.perimeterCircle(32.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 201.06192982974676d + "'", double1 == 201.06192982974676d);
    }

    @Test
    public void test0122() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0122");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-106.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-666.0176425610362d) + "'", double1 == (-666.0176425610362d));
    }

    @Test
    public void test0123() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0123");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9920.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 19840.0f + "'", float2 == 19840.0f);
    }

    @Test
    public void test0124() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0124");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 51.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 510.0f + "'", float2 == 510.0f);
    }

    @Test
    public void test0125() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0125");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-4.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-400.0f) + "'", float2 == (-400.0f));
    }

    @Test
    public void test0126() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0126");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0127() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0127");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-36.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-226.1946710584651d) + "'", double1 == (-226.1946710584651d));
    }

    @Test
    public void test0128() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0128");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3768.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 23675.042237452682d + "'", double1 == 23675.042237452682d);
    }

    @Test
    public void test0129() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0129");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 100);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 628.3185307179587d + "'", double1 == 628.3185307179587d);
    }

    @Test
    public void test0130() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0130");
        double double1 = org.example.maths.Perimeter.perimeterCircle(21470.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 134899.98854514572d + "'", double1 == 134899.98854514572d);
    }

    @Test
    public void test0131() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0131");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-58.0f), 2.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-112.0f) + "'", float2 == (-112.0f));
    }

    @Test
    public void test0132() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0132");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-9920.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-62329.198247221495d) + "'", double1 == (-62329.198247221495d));
    }

    @Test
    public void test0133() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0133");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (float) 0L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0134() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0134");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21400.0f, 21470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85740.0f + "'", float2 == 85740.0f);
    }

    @Test
    public void test0135() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0135");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) -1, 21470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42938.0f + "'", float2 == 42938.0f);
    }

    @Test
    public void test0136() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0136");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 42932.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 429320.0f + "'", float2 == 429320.0f);
    }

    @Test
    public void test0137() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0137");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 3768.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 37680.0f + "'", float2 == 37680.0f);
    }

    @Test
    public void test0138() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0138");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19800.0f), (float) (byte) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-39602.0f) + "'", float2 == (-39602.0f));
    }

    @Test
    public void test0139() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0139");
        double double1 = org.example.maths.Perimeter.perimeterCircle(66.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 414.6902302738527d + "'", double1 == 414.6902302738527d);
    }

    @Test
    public void test0140() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0140");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (float) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0141() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0141");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-1079.0f), (-19800.0f), 400.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0142() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0142");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 4675.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 46750.0f + "'", float2 == 46750.0f);
    }

    @Test
    public void test0143() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0143");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9352.0f, 1102.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20908.0f + "'", float2 == 20908.0f);
    }

    @Test
    public void test0144() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0144");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-9920.0f), (float) (byte) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-19820.0f) + "'", float2 == (-19820.0f));
    }

    @Test
    public void test0145() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0145");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, (-9920.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9920.0f) + "'", float2 == (-9920.0f));
    }

    @Test
    public void test0146() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0146");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 20.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2000.0f + "'", float2 == 2000.0f);
    }

    @Test
    public void test0147() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0147");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-58.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 58.0f + "'", float2 == 58.0f);
    }

    @Test
    public void test0148() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0148");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(34.0f, 34.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 136.0f + "'", float2 == 136.0f);
    }

    @Test
    public void test0149() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0149");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 1, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.0f + "'", float2 == 2.0f);
    }

    @Test
    public void test0150() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0150");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) '#', (-19800.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-39530.0f) + "'", float2 == (-39530.0f));
    }

    @Test
    public void test0151() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0151");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 100L, 42938.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 86076.0f + "'", float2 == 86076.0f);
    }

    @Test
    public void test0152() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0152");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 34.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 34.0f + "'", float2 == 34.0f);
    }

    @Test
    public void test0153() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0153");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-38608.0f) + "'", float2 == (-38608.0f));
    }

    @Test
    public void test0154() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0154");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-97.0f), (float) (byte) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-196.0f) + "'", float2 == (-196.0f));
    }

    @Test
    public void test0155() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0155");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(18.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 36.0f + "'", float2 == 36.0f);
    }

    @Test
    public void test0156() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0156");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41746.0f, 1456.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 86404.0f + "'", float2 == 86404.0f);
    }

    @Test
    public void test0157() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0157");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 812.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 81200.0f + "'", float2 == 81200.0f);
    }

    @Test
    public void test0158() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0158");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 46750.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0159() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0159");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0160() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0160");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6638.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 41707.78406905809d + "'", double1 == 41707.78406905809d);
    }

    @Test
    public void test0161() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0161");
        double double1 = org.example.maths.Perimeter.perimeterCircle(136.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 854.5132017764238d + "'", double1 == 854.5132017764238d);
    }

    @Test
    public void test0162() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0162");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41835.0f, 13012.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 109694.0f + "'", float2 == 109694.0f);
    }

    @Test
    public void test0163() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0163");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-25.132741228718345d) + "'", double1 == (-25.132741228718345d));
    }

    @Test
    public void test0164() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0164");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 100L);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 628.3185307179587d + "'", double1 == 628.3185307179587d);
    }

    @Test
    public void test0165() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0165");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-97.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0166() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0166");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(51.0f, 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 77318.0f + "'", float2 == 77318.0f);
    }

    @Test
    public void test0167() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0167");
        double double1 = org.example.maths.Perimeter.perimeterCircle(46750.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 293738.91311064566d + "'", double1 == 293738.91311064566d);
    }

    @Test
    public void test0168() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0168");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-38.0f), (float) 'a', 6506.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0169() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0169");
        double double1 = org.example.maths.Perimeter.perimeterCircle(843.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5296.725213952392d + "'", double1 == 5296.725213952392d);
    }

    @Test
    public void test0170() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0170");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.0f, 18.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 40.0f + "'", float2 == 40.0f);
    }

    @Test
    public void test0171() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0171");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 20283.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2028300.0f + "'", float2 == 2028300.0f);
    }

    @Test
    public void test0172() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0172");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 38608.0f + "'", float2 == 38608.0f);
    }

    @Test
    public void test0173() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0173");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 4724.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0174() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0174");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (float) (byte) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0175() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0175");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (byte) -1);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6.283185307179586d) + "'", double1 == (-6.283185307179586d));
    }

    @Test
    public void test0176() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0176");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20908.0f, (-19805.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2206.0f + "'", float2 == 2206.0f);
    }

    @Test
    public void test0177() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0177");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(135.0f, 42697.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85664.0f + "'", float2 == 85664.0f);
    }

    @Test
    public void test0178() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0178");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(32.0f, (-66.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-68.0f) + "'", float2 == (-68.0f));
    }

    @Test
    public void test0179() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0179");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9700.0f, 34.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 19468.0f + "'", float2 == 19468.0f);
    }

    @Test
    public void test0180() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0180");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (-1), 10100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20198.0f + "'", float2 == 20198.0f);
    }

    @Test
    public void test0181() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0181");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 135.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1350.0f + "'", float2 == 1350.0f);
    }

    @Test
    public void test0182() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0182");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19800.0f), 2206.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-35188.0f) + "'", float2 == (-35188.0f));
    }

    @Test
    public void test0183() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0183");
        double double1 = org.example.maths.Perimeter.perimeterCircle(18.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 113.09733552923255d + "'", double1 == 113.09733552923255d);
    }

    @Test
    public void test0184() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0184");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (float) (byte) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0185() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0185");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 2206.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2206.0f) + "'", float2 == (-2206.0f));
    }

    @Test
    public void test0186() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0186");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9700.0f, 1228.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 21856.0f + "'", float2 == 21856.0f);
    }

    @Test
    public void test0187() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0187");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6506.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 40878.40360851039d + "'", double1 == 40878.40360851039d);
    }

    @Test
    public void test0188() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0188");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 4724.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 151168.0f + "'", float2 == 151168.0f);
    }

    @Test
    public void test0189() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0189");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0190() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0190");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 5100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5100.0f + "'", float2 == 5100.0f);
    }

    @Test
    public void test0191() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0191");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4724.0f, (-69.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9310.0f + "'", float2 == 9310.0f);
    }

    @Test
    public void test0192() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0192");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 1350.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 135000.0f + "'", float2 == 135000.0f);
    }

    @Test
    public void test0193() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0193");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(17.0f, 1102.0f, (-100.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0194() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0194");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(81200.0f, (-9920.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 142560.0f + "'", float2 == 142560.0f);
    }

    @Test
    public void test0195() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0195");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4320.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 27143.36052701581d + "'", double1 == 27143.36052701581d);
    }

    @Test
    public void test0196() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0196");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (-1), 844.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1686.0f + "'", float2 == 1686.0f);
    }

    @Test
    public void test0197() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0197");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(38608.0f, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 77268.0f + "'", float2 == 77268.0f);
    }

    @Test
    public void test0198() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0198");
        double double1 = org.example.maths.Perimeter.perimeterCircle(202.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1269.2034320502764d + "'", double1 == 1269.2034320502764d);
    }

    @Test
    public void test0199() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0199");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(202.0f, 17.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 438.0f + "'", float2 == 438.0f);
    }

    @Test
    public void test0200() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0200");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1032.0f, 9352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20768.0f + "'", float2 == 20768.0f);
    }

    @Test
    public void test0201() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0201");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 20283.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2028300.0f + "'", float2 == 2028300.0f);
    }

    @Test
    public void test0202() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0202");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1350.0f, 6506.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 15712.0f + "'", float2 == 15712.0f);
    }

    @Test
    public void test0203() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0203");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(136.0f, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 324.0f + "'", float2 == 324.0f);
    }

    @Test
    public void test0204() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0204");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-38.0f), (float) (short) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-74.0f) + "'", float2 == (-74.0f));
    }

    @Test
    public void test0205() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0205");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42938.0f, (-192.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85492.0f + "'", float2 == 85492.0f);
    }

    @Test
    public void test0206() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0206");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-26.0f) + "'", float2 == (-26.0f));
    }

    @Test
    public void test0207() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0207");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 85740.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-85740.0f) + "'", float2 == (-85740.0f));
    }

    @Test
    public void test0208() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0208");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5626.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-35349.20053819235d) + "'", double1 == (-35349.20053819235d));
    }

    @Test
    public void test0209() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0209");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(40.0f, 10100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20280.0f + "'", float2 == 20280.0f);
    }

    @Test
    public void test0210() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0210");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21400.0f, (float) (-1L));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42798.0f + "'", float2 == 42798.0f);
    }

    @Test
    public void test0211() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0211");
        double double1 = org.example.maths.Perimeter.perimeterCircle(20280.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 127422.99802960201d + "'", double1 == 127422.99802960201d);
    }

    @Test
    public void test0212() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0212");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) '#');
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 219.9114857512855d + "'", double1 == 219.9114857512855d);
    }

    @Test
    public void test0213() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0213");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-35188.0f), (-0.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-70376.0f) + "'", float2 == (-70376.0f));
    }

    @Test
    public void test0214() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0214");
        double double1 = org.example.maths.Perimeter.perimeterCircle(109694.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 689227.7290857575d + "'", double1 == 689227.7290857575d);
    }

    @Test
    public void test0215() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0215");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (float) (short) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10.0f) + "'", float2 == (-10.0f));
    }

    @Test
    public void test0216() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0216");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-36.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 36.0f + "'", float2 == 36.0f);
    }

    @Test
    public void test0217() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0217");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 10.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0218() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0218");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 142560.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1425600.0f + "'", float2 == 1425600.0f);
    }

    @Test
    public void test0219() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0219");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 3348.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3348.0f + "'", float2 == 3348.0f);
    }

    @Test
    public void test0220() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0220");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) -1, 1102.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2202.0f + "'", float2 == 2202.0f);
    }

    @Test
    public void test0221() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0221");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 0, 252.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 504.0f + "'", float2 == 504.0f);
    }

    @Test
    public void test0222() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0222");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7292.0f, 69.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 14722.0f + "'", float2 == 14722.0f);
    }

    @Test
    public void test0223() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0223");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 1, 504400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1008802.0f + "'", float2 == 1008802.0f);
    }

    @Test
    public void test0224() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0224");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-70376.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0225() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0225");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-69.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 69.0f + "'", float2 == 69.0f);
    }

    @Test
    public void test0226() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0226");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42932.0f, (float) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 86064.0f + "'", float2 == 86064.0f);
    }

    @Test
    public void test0227() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0227");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-19820.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-124532.7327882994d) + "'", double1 == (-124532.7327882994d));
    }

    @Test
    public void test0228() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0228");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 220.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 21340.0f + "'", float2 == 21340.0f);
    }

    @Test
    public void test0229() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0229");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2206.0f), 4320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4228.0f + "'", float2 == 4228.0f);
    }

    @Test
    public void test0230() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0230");
        double double1 = org.example.maths.Perimeter.perimeterCircle(17.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 106.81415022205297d + "'", double1 == 106.81415022205297d);
    }

    @Test
    public void test0231() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0231");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42624.0f, 232.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85712.0f + "'", float2 == 85712.0f);
    }

    @Test
    public void test0232() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0232");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19805.0f), (float) 'a');
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-39416.0f) + "'", float2 == (-39416.0f));
    }

    @Test
    public void test0233() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0233");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (float) (byte) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0234() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0234");
        double double1 = org.example.maths.Perimeter.perimeterCircle(77318.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 485803.3215805112d + "'", double1 == 485803.3215805112d);
    }

    @Test
    public void test0235() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0235");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 260.0f + "'", float2 == 260.0f);
    }

    @Test
    public void test0236() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0236");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 18.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-18.0f) + "'", float2 == (-18.0f));
    }

    @Test
    public void test0237() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0237");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 6506.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0238() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0238");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5626.0f), (float) (-1L));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-11254.0f) + "'", float2 == (-11254.0f));
    }

    @Test
    public void test0239() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0239");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(136.0f, (float) 0L, 19468.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0240() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0240");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 10, 69.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 158.0f + "'", float2 == 158.0f);
    }

    @Test
    public void test0241() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0241");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(510.0f, 77318.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 155656.0f + "'", float2 == 155656.0f);
    }

    @Test
    public void test0242() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0242");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 21856.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2185600.0f + "'", float2 == 2185600.0f);
    }

    @Test
    public void test0243() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0243");
        double double1 = org.example.maths.Perimeter.perimeterCircle(170.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1068.1415022205297d + "'", double1 == 1068.1415022205297d);
    }

    @Test
    public void test0244() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0244");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (float) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 10.0f + "'", float2 == 10.0f);
    }

    @Test
    public void test0245() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0245");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21856.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 43712.0f + "'", float2 == 43712.0f);
    }

    @Test
    public void test0246() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0246");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(776.0f, 43712.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 88976.0f + "'", float2 == 88976.0f);
    }

    @Test
    public void test0247() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0247");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-39530.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0248() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0248");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5044.0f, (-38608.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-67128.0f) + "'", float2 == (-67128.0f));
    }

    @Test
    public void test0249() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0249");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(38101.0f, 41746.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 159694.0f + "'", float2 == 159694.0f);
    }

    @Test
    public void test0250() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0250");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-69.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6900.0f) + "'", float2 == (-6900.0f));
    }

    @Test
    public void test0251() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0251");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-39515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 39515.0f + "'", float2 == 39515.0f);
    }

    @Test
    public void test0252() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0252");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test0253() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0253");
        double double1 = org.example.maths.Perimeter.perimeterCircle(38608.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 242581.21833958945d + "'", double1 == 242581.21833958945d);
    }

    @Test
    public void test0254() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0254");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 159694.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.59694E7f + "'", float2 == 1.59694E7f);
    }

    @Test
    public void test0255() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0255");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1352.0f, (-29.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2646.0f + "'", float2 == 2646.0f);
    }

    @Test
    public void test0256() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0256");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(38473.0f, (-5387.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 66172.0f + "'", float2 == 66172.0f);
    }

    @Test
    public void test0257() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0257");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-6900.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-43353.97861953914d) + "'", double1 == (-43353.97861953914d));
    }

    @Test
    public void test0258() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0258");
        double double1 = org.example.maths.Perimeter.perimeterCircle(20.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 125.66370614359172d + "'", double1 == 125.66370614359172d);
    }

    @Test
    public void test0259() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0259");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 128386.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.28386E7f + "'", float2 == 1.28386E7f);
    }

    @Test
    public void test0260() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0260");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-97.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-970.0f) + "'", float2 == (-970.0f));
    }

    @Test
    public void test0261() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0261");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3449.0f, (-39416.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-71934.0f) + "'", float2 == (-71934.0f));
    }

    @Test
    public void test0262() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0262");
        double double1 = org.example.maths.Perimeter.perimeterCircle(10100.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 63460.17160251382d + "'", double1 == 63460.17160251382d);
    }

    @Test
    public void test0263() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0263");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(26.0f, 77268.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 154588.0f + "'", float2 == 154588.0f);
    }

    @Test
    public void test0264() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0264");
        double double1 = org.example.maths.Perimeter.perimeterCircle(36.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 226.1946710584651d + "'", double1 == 226.1946710584651d);
    }

    @Test
    public void test0265() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0265");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-11254.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-70710.96744699906d) + "'", double1 == (-70710.96744699906d));
    }

    @Test
    public void test0266() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0266");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(68.0f, 791.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1718.0f + "'", float2 == 1718.0f);
    }

    @Test
    public void test0267() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0267");
        double double1 = org.example.maths.Perimeter.perimeterCircle(159694.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1003386.9944447369d + "'", double1 == 1003386.9944447369d);
    }

    @Test
    public void test0268() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0268");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-106.0f), (-1079.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2370.0f) + "'", float2 == (-2370.0f));
    }

    @Test
    public void test0269() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0269");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19800.0f), 504400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 969200.0f + "'", float2 == 969200.0f);
    }

    @Test
    public void test0270() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0270");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(135000.0f, (-19800.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 230400.0f + "'", float2 == 230400.0f);
    }

    @Test
    public void test0271() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0271");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (float) (-1));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0272() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0272");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(15.0f, 2352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4734.0f + "'", float2 == 4734.0f);
    }

    @Test
    public void test0273() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0273");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1456.0f, 843.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4598.0f + "'", float2 == 4598.0f);
    }

    @Test
    public void test0274() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0274");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42624.0f, 597150.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1279548.0f + "'", float2 == 1279548.0f);
    }

    @Test
    public void test0275() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0275");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.0f, 42697.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85398.0f + "'", float2 == 85398.0f);
    }

    @Test
    public void test0276() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0276");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-738.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-738.0f) + "'", float2 == (-738.0f));
    }

    @Test
    public void test0277() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0277");
        double double1 = org.example.maths.Perimeter.perimeterCircle(57991.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 364368.1991486514d + "'", double1 == 364368.1991486514d);
    }

    @Test
    public void test0278() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0278");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 100, (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 400.0f + "'", float2 == 400.0f);
    }

    @Test
    public void test0279() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0279");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 90.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 90.0f + "'", float2 == 90.0f);
    }

    @Test
    public void test0280() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0280");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-39530.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2055560.0f) + "'", float2 == (-2055560.0f));
    }

    @Test
    public void test0281() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0281");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-38515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-385150.0f) + "'", float2 == (-385150.0f));
    }

    @Test
    public void test0282() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0282");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 100, (-39530.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-78860.0f) + "'", float2 == (-78860.0f));
    }

    @Test
    public void test0283() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0283");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0284() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0284");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14497.0f, 85740.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 200474.0f + "'", float2 == 200474.0f);
    }

    @Test
    public void test0285() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0285");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 14722.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0286() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0286");
        double double1 = org.example.maths.Perimeter.perimeterCircle(597150.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3752004.10618229d + "'", double1 == 3752004.10618229d);
    }

    @Test
    public void test0287() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0287");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-6900.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-241500.0f) + "'", float2 == (-241500.0f));
    }

    @Test
    public void test0288() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0288");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-39530.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 39530.0f + "'", float2 == 39530.0f);
    }

    @Test
    public void test0289() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0289");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (float) '4');
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0290() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0290");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42938.0f, 590839.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1267554.0f + "'", float2 == 1267554.0f);
    }

    @Test
    public void test0291() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0291");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-400.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2513.2741228718346d) + "'", double1 == (-2513.2741228718346d));
    }

    @Test
    public void test0292() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0292");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3016.0f), (-5626.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-17284.0f) + "'", float2 == (-17284.0f));
    }

    @Test
    public void test0293() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0293");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-38.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-238.76104167282426d) + "'", double1 == (-238.76104167282426d));
    }

    @Test
    public void test0294() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0294");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-66.0f), (float) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 68.0f + "'", float2 == 68.0f);
    }

    @Test
    public void test0295() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0295");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-36.0f), 62504.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 124936.0f + "'", float2 == 124936.0f);
    }

    @Test
    public void test0296() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0296");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-164.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1030.442390377452d) + "'", double1 == (-1030.442390377452d));
    }

    @Test
    public void test0297() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0297");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-738.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4636.990756698535d) + "'", double1 == (-4636.990756698535d));
    }

    @Test
    public void test0298() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0298");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14.0f, (float) (short) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 28.0f + "'", float2 == 28.0f);
    }

    @Test
    public void test0299() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0299");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.59694E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0033869944447368E8d + "'", double1 == 1.0033869944447368E8d);
    }

    @Test
    public void test0300() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0300");
        double double1 = org.example.maths.Perimeter.perimeterCircle(844.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5303.008399259571d + "'", double1 == 5303.008399259571d);
    }

    @Test
    public void test0301() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0301");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-38.0f), 85398.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 170720.0f + "'", float2 == 170720.0f);
    }

    @Test
    public void test0302() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0302");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(13012.0f, 232.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 26488.0f + "'", float2 == 26488.0f);
    }

    @Test
    public void test0303() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0303");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 438.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-438.0f) + "'", float2 == (-438.0f));
    }

    @Test
    public void test0304() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0304");
        double double1 = org.example.maths.Perimeter.perimeterCircle(250502.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1573950.4858191006d + "'", double1 == 1573950.4858191006d);
    }

    @Test
    public void test0305() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0305");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 260.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 260.0f + "'", float2 == 260.0f);
    }

    @Test
    public void test0306() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0306");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(100.0f, 2185600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4371400.0f + "'", float2 == 4371400.0f);
    }

    @Test
    public void test0307() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0307");
        double double1 = org.example.maths.Perimeter.perimeterCircle(85664.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 538242.7861542321d + "'", double1 == 538242.7861542321d);
    }

    @Test
    public void test0308() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0308");
        double double1 = org.example.maths.Perimeter.perimeterCircle(62504.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 392724.21443995286d + "'", double1 == 392724.21443995286d);
    }

    @Test
    public void test0309() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0309");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 4675.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0310() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0310");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-18.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-113.09733552923255d) + "'", double1 == (-113.09733552923255d));
    }

    @Test
    public void test0311() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0311");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-385150.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3851500.0f) + "'", float2 == (-3851500.0f));
    }

    @Test
    public void test0312() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0312");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(16.0f, 21400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42832.0f + "'", float2 == 42832.0f);
    }

    @Test
    public void test0313() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0313");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(40.0f, 1350.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2780.0f + "'", float2 == 2780.0f);
    }

    @Test
    public void test0314() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0314");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20908.0f, 131775.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 305366.0f + "'", float2 == 305366.0f);
    }

    @Test
    public void test0315() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0315");
        double double1 = org.example.maths.Perimeter.perimeterCircle(85398.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 536571.4588625223d + "'", double1 == 536571.4588625223d);
    }

    @Test
    public void test0316() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0316");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-88.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-552.9203070318035d) + "'", double1 == (-552.9203070318035d));
    }

    @Test
    public void test0317() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0317");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-198.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1244.0706908215582d) + "'", double1 == (-1244.0706908215582d));
    }

    @Test
    public void test0318() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0318");
        double double1 = org.example.maths.Perimeter.perimeterCircle(79130.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 497188.4533571207d + "'", double1 == 497188.4533571207d);
    }

    @Test
    public void test0319() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0319");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 21593.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-21593.0f) + "'", float2 == (-21593.0f));
    }

    @Test
    public void test0320() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0320");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 2028300.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2028300.0f) + "'", float2 == (-2028300.0f));
    }

    @Test
    public void test0321() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0321");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(10.0f, 202.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 424.0f + "'", float2 == 424.0f);
    }

    @Test
    public void test0322() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0322");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(214.0f, 20.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 468.0f + "'", float2 == 468.0f);
    }

    @Test
    public void test0323() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0323");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-400.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-40000.0f) + "'", float2 == (-40000.0f));
    }

    @Test
    public void test0324() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0324");
        double double1 = org.example.maths.Perimeter.perimeterCircle(13012.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 81756.80721702077d + "'", double1 == 81756.80721702077d);
    }

    @Test
    public void test0325() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0325");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(131775.0f, 20186.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 303922.0f + "'", float2 == 303922.0f);
    }

    @Test
    public void test0326() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0326");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 40.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4000.0f + "'", float2 == 4000.0f);
    }

    @Test
    public void test0327() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0327");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14722.0f, 9700.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 48844.0f + "'", float2 == 48844.0f);
    }

    @Test
    public void test0328() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0328");
        double double1 = org.example.maths.Perimeter.perimeterCircle(42832.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 269121.39307711605d + "'", double1 == 269121.39307711605d);
    }

    @Test
    public void test0329() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0329");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1702.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 10693.981392819656d + "'", double1 == 10693.981392819656d);
    }

    @Test
    public void test0330() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0330");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-10.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10.0f) + "'", float2 == (-10.0f));
    }

    @Test
    public void test0331() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0331");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-2055560.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.05556E8f) + "'", float2 == (-2.05556E8f));
    }

    @Test
    public void test0332() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0332");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 5100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 178500.0f + "'", float2 == 178500.0f);
    }

    @Test
    public void test0333() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0333");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-88.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8800.0f) + "'", float2 == (-8800.0f));
    }

    @Test
    public void test0334() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0334");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 57991.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 579910.0f + "'", float2 == 579910.0f);
    }

    @Test
    public void test0335() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0335");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(17.0f, 2352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4738.0f + "'", float2 == 4738.0f);
    }

    @Test
    public void test0336() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0336");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 78.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0337() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0337");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.5975563E7f, 86076.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.2123278E7f + "'", float2 == 3.2123278E7f);
    }

    @Test
    public void test0338() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0338");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-5626.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-56260.0f) + "'", float2 == (-56260.0f));
    }

    @Test
    public void test0339() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0339");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-17284.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1728400.0f) + "'", float2 == (-1728400.0f));
    }

    @Test
    public void test0340() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0340");
        double double1 = org.example.maths.Perimeter.perimeterCircle(19840.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 124658.39649444299d + "'", double1 == 124658.39649444299d);
    }

    @Test
    public void test0341() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0341");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-74904.0f), 232.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-149344.0f) + "'", float2 == (-149344.0f));
    }

    @Test
    public void test0342() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0342");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 14497.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 14497.0f + "'", float2 == 14497.0f);
    }

    @Test
    public void test0343() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0343");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85398.0f, 66317.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 303430.0f + "'", float2 == 303430.0f);
    }

    @Test
    public void test0344() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0344");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6.283185307179586d) + "'", double1 == (-6.283185307179586d));
    }

    @Test
    public void test0345() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0345");
        double double1 = org.example.maths.Perimeter.perimeterCircle(58.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 364.424747816416d + "'", double1 == 364.424747816416d);
    }

    @Test
    public void test0346() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0346");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-70376.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2252032.0f) + "'", float2 == (-2252032.0f));
    }

    @Test
    public void test0347() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0347");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9731.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 61141.676224164556d + "'", double1 == 61141.676224164556d);
    }

    @Test
    public void test0348() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0348");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 38608.0f + "'", float2 == 38608.0f);
    }

    @Test
    public void test0349() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0349");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-137.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-137.0f) + "'", float2 == (-137.0f));
    }

    @Test
    public void test0350() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0350");
        double double1 = org.example.maths.Perimeter.perimeterCircle(43712.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 274650.5961474341d + "'", double1 == 274650.5961474341d);
    }

    @Test
    public void test0351() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0351");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14.0f, (-29.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-30.0f) + "'", float2 == (-30.0f));
    }

    @Test
    public void test0352() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0352");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14497.0f, (float) 'a');
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 29188.0f + "'", float2 == 29188.0f);
    }

    @Test
    public void test0353() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0353");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2252032.0f), 39515.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4425034.0f) + "'", float2 == (-4425034.0f));
    }

    @Test
    public void test0354() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0354");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 26.0f + "'", float2 == 26.0f);
    }

    @Test
    public void test0355() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0355");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-2055560.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4111120.0f) + "'", float2 == (-4111120.0f));
    }

    @Test
    public void test0356() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0356");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(135.0f, (-2028300.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4056330.0f) + "'", float2 == (-4056330.0f));
    }

    @Test
    public void test0357() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0357");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2028300.0f, (-35188.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3986224.0f + "'", float2 == 3986224.0f);
    }

    @Test
    public void test0358() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0358");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-10.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-62.83185307179586d) + "'", double1 == (-62.83185307179586d));
    }

    @Test
    public void test0359() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0359");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-39515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3951500.0f) + "'", float2 == (-3951500.0f));
    }

    @Test
    public void test0360() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0360");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(133455.0f, 1456.0f, 41459.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0361() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0361");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 53.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 530.0f + "'", float2 == 530.0f);
    }

    @Test
    public void test0362() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0362");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3174.0f), 18.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6312.0f) + "'", float2 == (-6312.0f));
    }

    @Test
    public void test0363() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0363");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-1.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test0364() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0364");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(50132.0f, 3449.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 107162.0f + "'", float2 == 107162.0f);
    }

    @Test
    public void test0365() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0365");
        double double1 = org.example.maths.Perimeter.perimeterCircle(38101.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 239395.64338884942d + "'", double1 == 239395.64338884942d);
    }

    @Test
    public void test0366() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0366");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(29188.0f, 359343.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 777062.0f + "'", float2 == 777062.0f);
    }

    @Test
    public void test0367() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0367");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-56260.0f), 173269.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 234018.0f + "'", float2 == 234018.0f);
    }

    @Test
    public void test0368() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0368");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 10, 1702.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3424.0f + "'", float2 == 3424.0f);
    }

    @Test
    public void test0369() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0369");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86076.0f, 3424.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 179000.0f + "'", float2 == 179000.0f);
    }

    @Test
    public void test0370() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0370");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 1, 718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1438.0f + "'", float2 == 1438.0f);
    }

    @Test
    public void test0371() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0371");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 170.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 17000.0f + "'", float2 == 17000.0f);
    }

    @Test
    public void test0372() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0372");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 20.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2000.0f + "'", float2 == 2000.0f);
    }

    @Test
    public void test0373() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0373");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6638.0f, 1426970.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2867216.0f + "'", float2 == 2867216.0f);
    }

    @Test
    public void test0374() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0374");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 21593.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 21593.0f + "'", float2 == 21593.0f);
    }

    @Test
    public void test0375() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0375");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(250502.0f, 2206.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 505416.0f + "'", float2 == 505416.0f);
    }

    @Test
    public void test0376() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0376");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(124936.0f, 178500.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 606872.0f + "'", float2 == 606872.0f);
    }

    @Test
    public void test0377() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0377");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-39602.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-248826.704534926d) + "'", double1 == (-248826.704534926d));
    }

    @Test
    public void test0378() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0378");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1438.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 14380.0f + "'", float2 == 14380.0f);
    }

    @Test
    public void test0379() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0379");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86404.0f, 41459.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 255726.0f + "'", float2 == 255726.0f);
    }

    @Test
    public void test0380() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0380");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(15211.0f, 42798.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 116018.0f + "'", float2 == 116018.0f);
    }

    @Test
    public void test0381() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0381");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 124931.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-124931.0f) + "'", float2 == (-124931.0f));
    }

    @Test
    public void test0382() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0382");
        double double1 = org.example.maths.Perimeter.perimeterCircle(135.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 848.2300164692441d + "'", double1 == 848.2300164692441d);
    }

    @Test
    public void test0383() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0383");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-137.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-860.7963870836033d) + "'", double1 == (-860.7963870836033d));
    }

    @Test
    public void test0384() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0384");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 52.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1664.0f + "'", float2 == 1664.0f);
    }

    @Test
    public void test0385() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0385");
        double double1 = org.example.maths.Perimeter.perimeterCircle(14380.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 90352.20471724245d + "'", double1 == 90352.20471724245d);
    }

    @Test
    public void test0386() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0386");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(133235.0f, (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 266670.0f + "'", float2 == 266670.0f);
    }

    @Test
    public void test0387() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0387");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (byte) 100);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 628.3185307179587d + "'", double1 == 628.3185307179587d);
    }

    @Test
    public void test0388() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0388");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 20186.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-20186.0f) + "'", float2 == (-20186.0f));
    }

    @Test
    public void test0389() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0389");
        double double1 = org.example.maths.Perimeter.perimeterCircle(324.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2035.7520395261859d + "'", double1 == 2035.7520395261859d);
    }

    @Test
    public void test0390() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0390");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14380.0f, 57991.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 144742.0f + "'", float2 == 144742.0f);
    }

    @Test
    public void test0391() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0391");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4724.0f, 85492.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 180432.0f + "'", float2 == 180432.0f);
    }

    @Test
    public void test0392() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0392");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3851500.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.4199688210602175E7d) + "'", double1 == (-2.4199688210602175E7d));
    }

    @Test
    public void test0393() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0393");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86064.0f, 19840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 211808.0f + "'", float2 == 211808.0f);
    }

    @Test
    public void test0394() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0394");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1217.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-7646.636518837557d) + "'", double1 == (-7646.636518837557d));
    }

    @Test
    public void test0395() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0395");
        double double1 = org.example.maths.Perimeter.perimeterCircle(66172.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 415770.9381466876d + "'", double1 == 415770.9381466876d);
    }

    @Test
    public void test0396() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0396");
        double double1 = org.example.maths.Perimeter.perimeterCircle(85598.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 537828.0959239582d + "'", double1 == 537828.0959239582d);
    }

    @Test
    public void test0397() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0397");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(179000.0f, (float) (short) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 358002.0f + "'", float2 == 358002.0f);
    }

    @Test
    public void test0398() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0398");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85856.0f, (float) (-1));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 171710.0f + "'", float2 == 171710.0f);
    }

    @Test
    public void test0399() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0399");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6638.0f, (-137.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 13002.0f + "'", float2 == 13002.0f);
    }

    @Test
    public void test0400() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0400");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (float) (byte) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1000.0f + "'", float2 == 1000.0f);
    }

    @Test
    public void test0401() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0401");
        double double1 = org.example.maths.Perimeter.perimeterCircle(86064.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 540756.0602771039d + "'", double1 == 540756.0602771039d);
    }

    @Test
    public void test0402() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0402");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4000.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 25132.741228718343d + "'", double1 == 25132.741228718343d);
    }

    @Test
    public void test0403() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0403");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42624.0f, 48672.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 182592.0f + "'", float2 == 182592.0f);
    }

    @Test
    public void test0404() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0404");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 171710.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1717100.0f + "'", float2 == 1717100.0f);
    }

    @Test
    public void test0405() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0405");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 4958.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 480926.0f + "'", float2 == 480926.0f);
    }

    @Test
    public void test0406() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0406");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 606872.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6068720.0f + "'", float2 == 6068720.0f);
    }

    @Test
    public void test0407() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0407");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(158.0f, 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 77532.0f + "'", float2 == 77532.0f);
    }

    @Test
    public void test0408() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0408");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5387.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-33847.51924977643d) + "'", double1 == (-33847.51924977643d));
    }

    @Test
    public void test0409() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0409");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 2792.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2792.0f + "'", float2 == 2792.0f);
    }

    @Test
    public void test0410() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0410");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(144742.0f, 41746.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 372976.0f + "'", float2 == 372976.0f);
    }

    @Test
    public void test0411() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0411");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5626.0f), (float) (byte) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-11252.0f) + "'", float2 == (-11252.0f));
    }

    @Test
    public void test0412() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0412");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9700.0f, (-1.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 19398.0f + "'", float2 == 19398.0f);
    }

    @Test
    public void test0413() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0413");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 85712.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85712.0f + "'", float2 == 85712.0f);
    }

    @Test
    public void test0414() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0414");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(170.0f, (-39731.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-79122.0f) + "'", float2 == (-79122.0f));
    }

    @Test
    public void test0415() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0415");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 20.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 40.0f + "'", float2 == 40.0f);
    }

    @Test
    public void test0416() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0416");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5044.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 31692.386689413834d + "'", double1 == 31692.386689413834d);
    }

    @Test
    public void test0417() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0417");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-10.0f), (-124931.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-249882.0f) + "'", float2 == (-249882.0f));
    }

    @Test
    public void test0418() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0418");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(429320.0f, 170720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1200080.0f + "'", float2 == 1200080.0f);
    }

    @Test
    public void test0419() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0419");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 358002.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 716004.0f + "'", float2 == 716004.0f);
    }

    @Test
    public void test0420() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0420");
        double double1 = org.example.maths.Perimeter.perimeterCircle(434280.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2728661.7152019506d + "'", double1 == 2728661.7152019506d);
    }

    @Test
    public void test0421() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0421");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (float) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test0422() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0422");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(776.0f, (-84.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1384.0f + "'", float2 == 1384.0f);
    }

    @Test
    public void test0423() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0423");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 69.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-69.0f) + "'", float2 == (-69.0f));
    }

    @Test
    public void test0424() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0424");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 10.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20.0f + "'", float2 == 20.0f);
    }

    @Test
    public void test0425() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0425");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1279548.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.279548E8f + "'", float2 == 1.279548E8f);
    }

    @Test
    public void test0426() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0426");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0427() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0427");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 305366.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 305366.0f + "'", float2 == 305366.0f);
    }

    @Test
    public void test0428() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0428");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(232.0f, (-74.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 316.0f + "'", float2 == 316.0f);
    }

    @Test
    public void test0429() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0429");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1228.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42980.0f + "'", float2 == 42980.0f);
    }

    @Test
    public void test0430() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0430");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.0f, 151168.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 302342.0f + "'", float2 == 302342.0f);
    }

    @Test
    public void test0431() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0431");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 2646.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 26460.0f + "'", float2 == 26460.0f);
    }

    @Test
    public void test0432() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0432");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85712.0f, (-14890.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 141644.0f + "'", float2 == 141644.0f);
    }

    @Test
    public void test0433() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0433");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 0, 170.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 340.0f + "'", float2 == 340.0f);
    }

    @Test
    public void test0434() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0434");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) -1, 468.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 934.0f + "'", float2 == 934.0f);
    }

    @Test
    public void test0435() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0435");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1717100.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0788857490958067E7d + "'", double1 == 1.0788857490958067E7d);
    }

    @Test
    public void test0436() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0436");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-36.0f), 21133.0f, 81200.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0437() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0437");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) (short) 0);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 0.0d + "'", double1 == 0.0d);
    }

    @Test
    public void test0438() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0438");
        double double1 = org.example.maths.Perimeter.perimeterCircle(37680.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 236750.4223745268d + "'", double1 == 236750.4223745268d);
    }

    @Test
    public void test0439() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0439");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 46750.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 93500.0f + "'", float2 == 93500.0f);
    }

    @Test
    public void test0440() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0440");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-14812.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-93066.54076994403d) + "'", double1 == (-93066.54076994403d));
    }

    @Test
    public void test0441() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0441");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-78163.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7816300.0f) + "'", float2 == (-7816300.0f));
    }

    @Test
    public void test0442() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0442");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-88.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2816.0f) + "'", float2 == (-2816.0f));
    }

    @Test
    public void test0443() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0443");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-10.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0444() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0444");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-100.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 100.0f + "'", float2 == 100.0f);
    }

    @Test
    public void test0445() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0445");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-74904.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-749040.0f) + "'", float2 == (-749040.0f));
    }

    @Test
    public void test0446() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0446");
        double double1 = org.example.maths.Perimeter.perimeterCircle(42097.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 264503.251876339d + "'", double1 == 264503.251876339d);
    }

    @Test
    public void test0447() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0447");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 48844.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-48844.0f) + "'", float2 == (-48844.0f));
    }

    @Test
    public void test0448() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0448");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-7816300.0f), 1120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.563036E7f) + "'", float2 == (-1.563036E7f));
    }

    @Test
    public void test0449() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0449");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-38515.0f), 798.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-75434.0f) + "'", float2 == (-75434.0f));
    }

    @Test
    public void test0450() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0450");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 716004.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.16004E7f + "'", float2 == 7.16004E7f);
    }

    @Test
    public void test0451() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0451");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(52.0f, 42938.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85980.0f + "'", float2 == 85980.0f);
    }

    @Test
    public void test0452() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0452");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 66317.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0453() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0453");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(776.0f, (-36.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1480.0f + "'", float2 == 1480.0f);
    }

    @Test
    public void test0454() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0454");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(260.0f, 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 652.0f + "'", float2 == 652.0f);
    }

    @Test
    public void test0455() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0455");
        double double1 = org.example.maths.Perimeter.perimeterCircle(48672.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 305815.1952710448d + "'", double1 == 305815.1952710448d);
    }

    @Test
    public void test0456() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0456");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2867216.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8015249443710223E7d + "'", double1 == 1.8015249443710223E7d);
    }

    @Test
    public void test0457() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0457");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 88976.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 889760.0f + "'", float2 == 889760.0f);
    }

    @Test
    public void test0458() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0458");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 0L, (-78163.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-156326.0f) + "'", float2 == (-156326.0f));
    }

    @Test
    public void test0459() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0459");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 85740.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0460() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0460");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 230400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2304000.0f + "'", float2 == 2304000.0f);
    }

    @Test
    public void test0461() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0461");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(158.0f, (-137.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42.0f + "'", float2 == 42.0f);
    }

    @Test
    public void test0462() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0462");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-156326.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-982225.226330156d) + "'", double1 == (-982225.226330156d));
    }

    @Test
    public void test0463() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0463");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 597150.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.090025E7f + "'", float2 == 2.090025E7f);
    }

    @Test
    public void test0464() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0464");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7772.0f, (-37192.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-58840.0f) + "'", float2 == (-58840.0f));
    }

    @Test
    public void test0465() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0465");
        double double1 = org.example.maths.Perimeter.perimeterCircle(10.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 62.83185307179586d + "'", double1 == 62.83185307179586d);
    }

    @Test
    public void test0466() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0466");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-39602.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 39602.0f + "'", float2 == 39602.0f);
    }

    @Test
    public void test0467() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0467");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-74.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-464.9557127312894d) + "'", double1 == (-464.9557127312894d));
    }

    @Test
    public void test0468() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0468");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 180432.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9382464.0f + "'", float2 == 9382464.0f);
    }

    @Test
    public void test0469() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0469");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-38608.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-242581.21833958945d) + "'", double1 == (-242581.21833958945d));
    }

    @Test
    public void test0470() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0470");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-4056330.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.10929152E8f) + "'", float2 == (-2.10929152E8f));
    }

    @Test
    public void test0471() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0471");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 66317.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0472() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0472");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.28386E7f, 19468.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.5716136E7f + "'", float2 == 2.5716136E7f);
    }

    @Test
    public void test0473() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0473");
        double double1 = org.example.maths.Perimeter.perimeterCircle(169158.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1062851.0601918844d + "'", double1 == 1062851.0601918844d);
    }

    @Test
    public void test0474() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0474");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-67242.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-67242.0f) + "'", float2 == (-67242.0f));
    }

    @Test
    public void test0475() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0475");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 1.27959576E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.27959576E8f) + "'", float2 == (-1.27959576E8f));
    }

    @Test
    public void test0476() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0476");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-196.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1231.5043202071988d) + "'", double1 == (-1231.5043202071988d));
    }

    @Test
    public void test0477() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0477");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(144742.0f, 1384.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 292252.0f + "'", float2 == 292252.0f);
    }

    @Test
    public void test0478() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0478");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-39530.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-39530.0f) + "'", float2 == (-39530.0f));
    }

    @Test
    public void test0479() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0479");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0480() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0480");
        double double1 = org.example.maths.Perimeter.perimeterCircle(505416.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3175622.3852134775d + "'", double1 == 3175622.3852134775d);
    }

    @Test
    public void test0481() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0481");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 266670.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0482() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0482");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-112.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-703.7167544041137d) + "'", double1 == (-703.7167544041137d));
    }

    @Test
    public void test0483() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0483");
        double double1 = org.example.maths.Perimeter.perimeterCircle(200474.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1259615.2912715203d + "'", double1 == 1259615.2912715203d);
    }

    @Test
    public void test0484() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0484");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 68.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 680.0f + "'", float2 == 680.0f);
    }

    @Test
    public void test0485() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0485");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(38101.0f, 2020.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 80242.0f + "'", float2 == 80242.0f);
    }

    @Test
    public void test0486() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0486");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2185600.0f, 14497.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4400194.0f + "'", float2 == 4400194.0f);
    }

    @Test
    public void test0487() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0487");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-1079.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0488() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0488");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(504.0f, 843.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2694.0f + "'", float2 == 2694.0f);
    }

    @Test
    public void test0489() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0489");
        double double1 = org.example.maths.Perimeter.perimeterCircle(85492.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 537162.0782813972d + "'", double1 == 537162.0782813972d);
    }

    @Test
    public void test0490() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0490");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-5387.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-188545.0f) + "'", float2 == (-188545.0f));
    }

    @Test
    public void test0491() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0491");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 653984.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 653984.0f + "'", float2 == 653984.0f);
    }

    @Test
    public void test0492() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0492");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.563036E7f), 29188.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.1202344E7f) + "'", float2 == (-3.1202344E7f));
    }

    @Test
    public void test0493() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0493");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1008802.0f, 2320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2022244.0f + "'", float2 == 2022244.0f);
    }

    @Test
    public void test0494() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0494");
        double double1 = org.example.maths.Perimeter.perimeterCircle(170635.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1072131.3248905886d + "'", double1 == 1072131.3248905886d);
    }

    @Test
    public void test0495() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0495");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(28.0f, 142560.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 285176.0f + "'", float2 == 285176.0f);
    }

    @Test
    public void test0496() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0496");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(173627.0f, 20283.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 387820.0f + "'", float2 == 387820.0f);
    }

    @Test
    public void test0497() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0497");
        double double1 = org.example.maths.Perimeter.perimeterCircle(19468.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 122321.05156017219d + "'", double1 == 122321.05156017219d);
    }

    @Test
    public void test0498() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0498");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(43712.0f, 131880.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 351184.0f + "'", float2 == 351184.0f);
    }

    @Test
    public void test0499() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0499");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 886312.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8863120.0f + "'", float2 == 8863120.0f);
    }

    @Test
    public void test0500() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0500");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(358002.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 716004.0f + "'", float2 == 716004.0f);
    }

    @Test
    public void test0501() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0501");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 66172.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-66172.0f) + "'", float2 == (-66172.0f));
    }

    @Test
    public void test0502() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0502");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(66172.0f, 13012.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 158368.0f + "'", float2 == 158368.0f);
    }

    @Test
    public void test0503() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0503");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-67242.0f), 20908.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-92668.0f) + "'", float2 == (-92668.0f));
    }

    @Test
    public void test0504() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0504");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1267554.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7964276.668856713d + "'", double1 == 7964276.668856713d);
    }

    @Test
    public void test0505() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0505");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1677285.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0538692467952712E7d + "'", double1 == 1.0538692467952712E7d);
    }

    @Test
    public void test0506() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0506");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1000.0f, (-71012.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-140024.0f) + "'", float2 == (-140024.0f));
    }

    @Test
    public void test0507() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0507");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(158368.0f, 26488.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 369712.0f + "'", float2 == 369712.0f);
    }

    @Test
    public void test0508() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0508");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.5716136E7f, (float) 100L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1432472E7f + "'", float2 == 5.1432472E7f);
    }

    @Test
    public void test0509() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0509");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0510() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0510");
        double double1 = org.example.maths.Perimeter.perimeterCircle(429197.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2696724.284285557d + "'", double1 == 2696724.284285557d);
    }

    @Test
    public void test0511() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0511");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(155107.0f, (-88.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 310038.0f + "'", float2 == 310038.0f);
    }

    @Test
    public void test0512() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0512");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85664.0f, 359343.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 890014.0f + "'", float2 == 890014.0f);
    }

    @Test
    public void test0513() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0513");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(211808.0f, 178500.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 780616.0f + "'", float2 == 780616.0f);
    }

    @Test
    public void test0514() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0514");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-229267.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1440527.0458211422d) + "'", double1 == (-1440527.0458211422d));
    }

    @Test
    public void test0515() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0515");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(166025.0f, 74345.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 480740.0f + "'", float2 == 480740.0f);
    }

    @Test
    public void test0516() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0516");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 4400194.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.400194E7f + "'", float2 == 4.400194E7f);
    }

    @Test
    public void test0517() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0517");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 41835.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1338720.0f + "'", float2 == 1338720.0f);
    }

    @Test
    public void test0518() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0518");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 180432.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7501904E7f + "'", float2 == 1.7501904E7f);
    }

    @Test
    public void test0519() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0519");
        double double1 = org.example.maths.Perimeter.perimeterCircle(85661.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 538223.9365983105d + "'", double1 == 538223.9365983105d);
    }

    @Test
    public void test0520() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0520");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.090025E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.3132014371638015E8d + "'", double1 == 1.3132014371638015E8d);
    }

    @Test
    public void test0521() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0521");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 85661.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8566100.0f + "'", float2 == 8566100.0f);
    }

    @Test
    public void test0522() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0522");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.8116994E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.6233988E7f + "'", float2 == 5.6233988E7f);
    }

    @Test
    public void test0523() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0523");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0524() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0524");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(173269.0f, (-100.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 346338.0f + "'", float2 == 346338.0f);
    }

    @Test
    public void test0525() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0525");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-1217.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-12170.0f) + "'", float2 == (-12170.0f));
    }

    @Test
    public void test0526() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0526");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 186445.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.86445E7f + "'", float2 == 1.86445E7f);
    }

    @Test
    public void test0527() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0527");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-0.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0528() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0528");
        double double1 = org.example.maths.Perimeter.perimeterCircle(186445.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1171468.4845970978d + "'", double1 == 1171468.4845970978d);
    }

    @Test
    public void test0529() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0529");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-100.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-628.3185307179587d) + "'", double1 == (-628.3185307179587d));
    }

    @Test
    public void test0530() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0530");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 340.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-340.0f) + "'", float2 == (-340.0f));
    }

    @Test
    public void test0531() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0531");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1384.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8695.928465136547d + "'", double1 == 8695.928465136547d);
    }

    @Test
    public void test0532() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0532");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(15211.0f, 1122385.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2275192.0f + "'", float2 == 2275192.0f);
    }

    @Test
    public void test0533() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0533");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(128386.0f, 20186.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 297144.0f + "'", float2 == 297144.0f);
    }

    @Test
    public void test0534() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0534");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(901.0f, 1718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5238.0f + "'", float2 == 5238.0f);
    }

    @Test
    public void test0535() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0535");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41746.0f, (float) (byte) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 83494.0f + "'", float2 == 83494.0f);
    }

    @Test
    public void test0536() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0536");
        double double1 = org.example.maths.Perimeter.perimeterCircle(889760.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5590526.958916109d + "'", double1 == 5590526.958916109d);
    }

    @Test
    public void test0537() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0537");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 888126.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-888126.0f) + "'", float2 == (-888126.0f));
    }

    @Test
    public void test0538() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0538");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1375069.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.37506896E8f + "'", float2 == 1.37506896E8f);
    }

    @Test
    public void test0539() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0539");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(316.0f, 80242.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 161116.0f + "'", float2 == 161116.0f);
    }

    @Test
    public void test0540() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0540");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(170635.0f, 346338.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1033946.0f + "'", float2 == 1033946.0f);
    }

    @Test
    public void test0541() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0541");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-14890.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-93556.62922390403d) + "'", double1 == (-93556.62922390403d));
    }

    @Test
    public void test0542() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0542");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1456.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0543() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0543");
        double double1 = org.example.maths.Perimeter.perimeterCircle(124936.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 784996.0395377888d + "'", double1 == 784996.0395377888d);
    }

    @Test
    public void test0544() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0544");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 1702.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 17020.0f + "'", float2 == 17020.0f);
    }

    @Test
    public void test0545() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0545");
        double double1 = org.example.maths.Perimeter.perimeterCircle(131775.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 827966.74385359d + "'", double1 == 827966.74385359d);
    }

    @Test
    public void test0546() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0546");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-39515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1264480.0f) + "'", float2 == (-1264480.0f));
    }

    @Test
    public void test0547() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0547");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42624.0f, 1664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 88576.0f + "'", float2 == 88576.0f);
    }

    @Test
    public void test0548() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0548");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2320.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 14576.98991265664d + "'", double1 == 14576.98991265664d);
    }

    @Test
    public void test0549() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0549");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(80911.0f, 39840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 241502.0f + "'", float2 == 241502.0f);
    }

    @Test
    public void test0550() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0550");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 230400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 230400.0f + "'", float2 == 230400.0f);
    }

    @Test
    public void test0551() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0551");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 0, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0552() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0552");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(39279.0f, 86076.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 250710.0f + "'", float2 == 250710.0f);
    }

    @Test
    public void test0553() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0553");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(173627.0f, (-749040.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1150826.0f) + "'", float2 == (-1150826.0f));
    }

    @Test
    public void test0554() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0554");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 2867216.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2867216.0f + "'", float2 == 2867216.0f);
    }

    @Test
    public void test0555() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0555");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.28386E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.066730288475583E7d + "'", double1 == 8.066730288475583E7d);
    }

    @Test
    public void test0556() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0556");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 9352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 18704.0f + "'", float2 == 18704.0f);
    }

    @Test
    public void test0557() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0557");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 151168.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4663296E7f + "'", float2 == 1.4663296E7f);
    }

    @Test
    public void test0558() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0558");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1150826.0f), (-137.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2301926.0f) + "'", float2 == (-2301926.0f));
    }

    @Test
    public void test0559() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0559");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 852.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-852.0f) + "'", float2 == (-852.0f));
    }

    @Test
    public void test0560() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0560");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-438.0f), 80911.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 160946.0f + "'", float2 == 160946.0f);
    }

    @Test
    public void test0561() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0561");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.5975563E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0037742271552183E8d + "'", double1 == 1.0037742271552183E8d);
    }

    @Test
    public void test0562() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0562");
        double double1 = org.example.maths.Perimeter.perimeterCircle(18704.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 117520.69798548699d + "'", double1 == 117520.69798548699d);
    }

    @Test
    public void test0563() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0563");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5100.0f, 76567.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 163334.0f + "'", float2 == 163334.0f);
    }

    @Test
    public void test0564() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0564");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-43056.0f), 18676.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-48760.0f) + "'", float2 == (-48760.0f));
    }

    @Test
    public void test0565() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0565");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-17284.0f), 17.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-34534.0f) + "'", float2 == (-34534.0f));
    }

    @Test
    public void test0566() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0566");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 777062.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0567() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0567");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-137.0f), 4675.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9076.0f + "'", float2 == 9076.0f);
    }

    @Test
    public void test0568() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0568");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(170635.0f, 38473.0f, 4724.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0569() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0569");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 19840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0570() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0570");
        double double1 = org.example.maths.Perimeter.perimeterCircle(51.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 320.4424506661589d + "'", double1 == 320.4424506661589d);
    }

    @Test
    public void test0571() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0571");
        double double1 = org.example.maths.Perimeter.perimeterCircle(90.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 565.4866776461628d + "'", double1 == 565.4866776461628d);
    }

    @Test
    public void test0572() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0572");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) -1, (-52964.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-105930.0f) + "'", float2 == (-105930.0f));
    }

    @Test
    public void test0573() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0573");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-100.0f), (-2370.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4940.0f) + "'", float2 == (-4940.0f));
    }

    @Test
    public void test0574() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0574");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1425600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2851200.0f + "'", float2 == 2851200.0f);
    }

    @Test
    public void test0575() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0575");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-30.0f), 1717100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3434140.0f + "'", float2 == 3434140.0f);
    }

    @Test
    public void test0576() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0576");
        double double1 = org.example.maths.Perimeter.perimeterCircle(14722.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 92501.05409229787d + "'", double1 == 92501.05409229787d);
    }

    @Test
    public void test0577() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0577");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2396175.0f, (-149344.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4493662.0f + "'", float2 == 4493662.0f);
    }

    @Test
    public void test0578() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0578");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 5.1432472E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1432472E7f + "'", float2 == 5.1432472E7f);
    }

    @Test
    public void test0579() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0579");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 160946.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.60946E7f + "'", float2 == 1.60946E7f);
    }

    @Test
    public void test0580() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0580");
        double double1 = org.example.maths.Perimeter.perimeterCircle(316.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1985.4865570687493d + "'", double1 == 1985.4865570687493d);
    }

    @Test
    public void test0581() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0581");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(48844.0f, 196059.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 489806.0f + "'", float2 == 489806.0f);
    }

    @Test
    public void test0582() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0582");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2283949.0f, (-78860.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4410178.0f + "'", float2 == 4410178.0f);
    }

    @Test
    public void test0583() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0583");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(10531.0f, 4320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 29702.0f + "'", float2 == 29702.0f);
    }

    @Test
    public void test0584() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0584");
        double double1 = org.example.maths.Perimeter.perimeterCircle(332007.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2086061.504280773d + "'", double1 == 2086061.504280773d);
    }

    @Test
    public void test0585() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0585");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1846426.0f, 100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3693052.0f + "'", float2 == 3693052.0f);
    }

    @Test
    public void test0586() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0586");
        double double1 = org.example.maths.Perimeter.perimeterCircle(653984.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4109102.6599305347d + "'", double1 == 4109102.6599305347d);
    }

    @Test
    public void test0587() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0587");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.05555968E8f), 1350.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.11109248E8f) + "'", float2 == (-4.11109248E8f));
    }

    @Test
    public void test0588() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0588");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 32.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0589() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0589");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2816.0f), 716004.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1426376.0f + "'", float2 == 1426376.0f);
    }

    @Test
    public void test0590() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0590");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0591() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0591");
        double double1 = org.example.maths.Perimeter.perimeterCircle(41459.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 260494.57965035847d + "'", double1 == 260494.57965035847d);
    }

    @Test
    public void test0592() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0592");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 116018.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 116018.0f + "'", float2 == 116018.0f);
    }

    @Test
    public void test0593() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0593");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 9700.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 970000.0f + "'", float2 == 970000.0f);
    }

    @Test
    public void test0594() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0594");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 21508.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0595() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0595");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3851500.0f), (float) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7703000.0f) + "'", float2 == (-7703000.0f));
    }

    @Test
    public void test0596() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0596");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-241500.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1517389.25168387d) + "'", double1 == (-1517389.25168387d));
    }

    @Test
    public void test0597() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0597");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(26.0f, 480926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 961904.0f + "'", float2 == 961904.0f);
    }

    @Test
    public void test0598() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0598");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(310038.0f, 232.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 620540.0f + "'", float2 == 620540.0f);
    }

    @Test
    public void test0599() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0599");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(68.0f, 510.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1156.0f + "'", float2 == 1156.0f);
    }

    @Test
    public void test0600() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0600");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1217.0f), 2867216.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5731998.0f + "'", float2 == 5731998.0f);
    }

    @Test
    public void test0601() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0601");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20280.0f, 67283.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 175126.0f + "'", float2 == 175126.0f);
    }

    @Test
    public void test0602() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0602");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 4371400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4371400.0f + "'", float2 == 4371400.0f);
    }

    @Test
    public void test0603() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0603");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-340.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-11900.0f) + "'", float2 == (-11900.0f));
    }

    @Test
    public void test0604() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0604");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(37483.0f, 42980.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 160926.0f + "'", float2 == 160926.0f);
    }

    @Test
    public void test0605() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0605");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(45784.0f, 13012.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 117592.0f + "'", float2 == 117592.0f);
    }

    @Test
    public void test0606() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0606");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.27959576E8f, 173627.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.562664E8f + "'", float2 == 2.562664E8f);
    }

    @Test
    public void test0607() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0607");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-1150826.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.9842952E7f) + "'", float2 == (-5.9842952E7f));
    }

    @Test
    public void test0608() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0608");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 18676.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1811572.0f + "'", float2 == 1811572.0f);
    }

    @Test
    public void test0609() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0609");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (float) (short) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 520.0f + "'", float2 == 520.0f);
    }

    @Test
    public void test0610() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0610");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-2.10929152E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0611() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0611");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.86445E7f, 10.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.728902E7f + "'", float2 == 3.728902E7f);
    }

    @Test
    public void test0612() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0612");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-52.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0613() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0613");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(19840.0f, 2851200.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5742080.0f + "'", float2 == 5742080.0f);
    }

    @Test
    public void test0614() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0614");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1425600.0f, (-1150826.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 549548.0f + "'", float2 == 549548.0f);
    }

    @Test
    public void test0615() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0615");
        double double1 = org.example.maths.Perimeter.perimeterCircle(310038.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1948026.2062673445d + "'", double1 == 1948026.2062673445d);
    }

    @Test
    public void test0616() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0616");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 1061.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 55172.0f + "'", float2 == 55172.0f);
    }

    @Test
    public void test0617() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0617");
        double double1 = org.example.maths.Perimeter.perimeterCircle(155107.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 974566.0234407041d + "'", double1 == 974566.0234407041d);
    }

    @Test
    public void test0618() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0618");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(36.0f, 14.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 100.0f + "'", float2 == 100.0f);
    }

    @Test
    public void test0619() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0619");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1456.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9148.317807253477d + "'", double1 == 9148.317807253477d);
    }

    @Test
    public void test0620() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0620");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-79122.0f), 332007.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 505770.0f + "'", float2 == 505770.0f);
    }

    @Test
    public void test0621() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0621");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 3.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 156.0f + "'", float2 == 156.0f);
    }

    @Test
    public void test0622() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0622");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 230400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 230400.0f + "'", float2 == 230400.0f);
    }

    @Test
    public void test0623() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0623");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1061.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6666.459610917541d + "'", double1 == 6666.459610917541d);
    }

    @Test
    public void test0624() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0624");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1364906.0f, (-2437.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2724938.0f + "'", float2 == 2724938.0f);
    }

    @Test
    public void test0625() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0625");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-21593.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-135672.8203379288d) + "'", double1 == (-135672.8203379288d));
    }

    @Test
    public void test0626() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0626");
        double double1 = org.example.maths.Perimeter.perimeterCircle(429320.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2697497.11607834d + "'", double1 == 2697497.11607834d);
    }

    @Test
    public void test0627() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0627");
        double double1 = org.example.maths.Perimeter.perimeterCircle(80268.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 504338.718236691d + "'", double1 == 504338.718236691d);
    }

    @Test
    public void test0628() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0628");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.27959576E8f), 2792.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.55913568E8f) + "'", float2 == (-2.55913568E8f));
    }

    @Test
    public void test0629() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0629");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2055560.0f), 9920.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4091280.0f) + "'", float2 == (-4091280.0f));
    }

    @Test
    public void test0630() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0630");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 66172.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 661720.0f + "'", float2 == 661720.0f);
    }

    @Test
    public void test0631() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0631");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-37192.0f), 351184.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 627984.0f + "'", float2 == 627984.0f);
    }

    @Test
    public void test0632() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0632");
        double double1 = org.example.maths.Perimeter.perimeterCircle(19398.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 121881.22858866962d + "'", double1 == 121881.22858866962d);
    }

    @Test
    public void test0633() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0633");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 387820.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.8782E7f + "'", float2 == 3.8782E7f);
    }

    @Test
    public void test0634() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0634");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(16.0f, 220.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 472.0f + "'", float2 == 472.0f);
    }

    @Test
    public void test0635() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0635");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-140024.0f), 186445.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 92842.0f + "'", float2 == 92842.0f);
    }

    @Test
    public void test0636() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0636");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 141644.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0637() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0637");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 85856.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8585600.0f + "'", float2 == 8585600.0f);
    }

    @Test
    public void test0638() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0638");
        double double1 = org.example.maths.Perimeter.perimeterCircle(372976.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2343477.323130613d + "'", double1 == 2343477.323130613d);
    }

    @Test
    public void test0639() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0639");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-48844.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1709540.0f) + "'", float2 == (-1709540.0f));
    }

    @Test
    public void test0640() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0640");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3213544.0f, 200474.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6828036.0f + "'", float2 == 6828036.0f);
    }

    @Test
    public void test0641() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0641");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 170635.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 170635.0f + "'", float2 == 170635.0f);
    }

    @Test
    public void test0642() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0642");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-241500.0f), (-150.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-483300.0f) + "'", float2 == (-483300.0f));
    }

    @Test
    public void test0643() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0643");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 131775.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1317750.0f + "'", float2 == 1317750.0f);
    }

    @Test
    public void test0644() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0644");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-70376.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-140752.0f) + "'", float2 == (-140752.0f));
    }

    @Test
    public void test0645() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0645");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1156.0f, (-39351.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-76390.0f) + "'", float2 == (-76390.0f));
    }

    @Test
    public void test0646() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0646");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 14380.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1438000.0f + "'", float2 == 1438000.0f);
    }

    @Test
    public void test0647() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0647");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 18655.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1865500.0f + "'", float2 == 1865500.0f);
    }

    @Test
    public void test0648() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0648");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0649() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0649");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(179689.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 359378.0f + "'", float2 == 359378.0f);
    }

    @Test
    public void test0650() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0650");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 161116.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0651() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0651");
        double double1 = org.example.maths.Perimeter.perimeterCircle(969200.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6089663.199718455d + "'", double1 == 6089663.199718455d);
    }

    @Test
    public void test0652() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0652");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(231280.0f, 886312.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2235184.0f + "'", float2 == 2235184.0f);
    }

    @Test
    public void test0653() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0653");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 3965.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 138775.0f + "'", float2 == 138775.0f);
    }

    @Test
    public void test0654() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0654");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(200474.0f, 14380.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 429708.0f + "'", float2 == 429708.0f);
    }

    @Test
    public void test0655() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0655");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-97.0f), 1718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3242.0f + "'", float2 == 3242.0f);
    }

    @Test
    public void test0656() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0656");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(844.0f, (-241500.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-481312.0f) + "'", float2 == (-481312.0f));
    }

    @Test
    public void test0657() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0657");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3424.0f, 18.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6884.0f + "'", float2 == 6884.0f);
    }

    @Test
    public void test0658() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0658");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(38608.0f, (-35188.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6840.0f + "'", float2 == 6840.0f);
    }

    @Test
    public void test0659() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0659");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-39351.0f), 3986224.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7893746.0f + "'", float2 == 7893746.0f);
    }

    @Test
    public void test0660() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0660");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.27959576E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-8.039937278361297E8d) + "'", double1 == (-8.039937278361297E8d));
    }

    @Test
    public void test0661() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0661");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1033946.0f, 1426376.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4920644.0f + "'", float2 == 4920644.0f);
    }

    @Test
    public void test0662() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0662");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.27964392E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.04023987656569E8d + "'", double1 == 8.04023987656569E8d);
    }

    @Test
    public void test0663() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0663");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1200080.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7540325.023440078d + "'", double1 == 7540325.023440078d);
    }

    @Test
    public void test0664() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0664");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-738.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 738.0f + "'", float2 == 738.0f);
    }

    @Test
    public void test0665() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0665");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5600.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 35185.83772020568d + "'", double1 == 35185.83772020568d);
    }

    @Test
    public void test0666() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0666");
        double double1 = org.example.maths.Perimeter.perimeterCircle(18676.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 117344.76879688595d + "'", double1 == 117344.76879688595d);
    }

    @Test
    public void test0667() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0667");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(232.0f, 1438.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3340.0f + "'", float2 == 3340.0f);
    }

    @Test
    public void test0668() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0668");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 285176.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9981160.0f + "'", float2 == 9981160.0f);
    }

    @Test
    public void test0669() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0669");
        double double1 = org.example.maths.Perimeter.perimeterCircle(161116.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1012321.6839515462d + "'", double1 == 1012321.6839515462d);
    }

    @Test
    public void test0670() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0670");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 888126.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0671() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0671");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-11900.0f), 305366.0f, 94196.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0672() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0672");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 889760.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0673() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0673");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 20280.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 648960.0f + "'", float2 == 648960.0f);
    }

    @Test
    public void test0674() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0674");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-21593.0f), 6068720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2094254E7f + "'", float2 == 1.2094254E7f);
    }

    @Test
    public void test0675() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0675");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-241500.0f), 41835.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-399330.0f) + "'", float2 == (-399330.0f));
    }

    @Test
    public void test0676() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0676");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(230400.0f, 266670.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 994140.0f + "'", float2 == 994140.0f);
    }

    @Test
    public void test0677() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0677");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 1.27965576E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.27965573E10f + "'", float2 == 1.27965573E10f);
    }

    @Test
    public void test0678() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0678");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.86445E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.171468484597098E8d + "'", double1 == 1.171468484597098E8d);
    }

    @Test
    public void test0679() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0679");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 3434140.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0680() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0680");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 93500.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-93500.0f) + "'", float2 == (-93500.0f));
    }

    @Test
    public void test0681() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0681");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-1.563036E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.563036E8f) + "'", float2 == (-1.563036E8f));
    }

    @Test
    public void test0682() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0682");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1425600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4256E8f + "'", float2 == 1.4256E8f);
    }

    @Test
    public void test0683() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0683");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-2301926.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2301926.0f + "'", float2 == 2301926.0f);
    }

    @Test
    public void test0684() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0684");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1122385.0f, 2851200.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7947170.0f + "'", float2 == 7947170.0f);
    }

    @Test
    public void test0685() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0685");
        double double1 = org.example.maths.Perimeter.perimeterCircle(961904.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6043821.079717273d + "'", double1 == 6043821.079717273d);
    }

    @Test
    public void test0686() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0686");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 80911.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-80911.0f) + "'", float2 == (-80911.0f));
    }

    @Test
    public void test0687() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0687");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(332007.0f, (-58.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 663898.0f + "'", float2 == 663898.0f);
    }

    @Test
    public void test0688() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0688");
        double double1 = org.example.maths.Perimeter.perimeterCircle(886312.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5568862.535976954d + "'", double1 == 5568862.535976954d);
    }

    @Test
    public void test0689() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0689");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(10100.0f, 14380.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 48960.0f + "'", float2 == 48960.0f);
    }

    @Test
    public void test0690() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0690");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4598.0f, 1425600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2860396.0f + "'", float2 == 2860396.0f);
    }

    @Test
    public void test0691() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0691");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(4228.0f, (-4.0f), 144742.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0692() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0692");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 944115.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 944115.0f + "'", float2 == 944115.0f);
    }

    @Test
    public void test0693() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0693");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-2264892.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.264892E7f) + "'", float2 == (-2.264892E7f));
    }

    @Test
    public void test0694() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0694");
        double double1 = org.example.maths.Perimeter.perimeterCircle(85856.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 539449.1577332106d + "'", double1 == 539449.1577332106d);
    }

    @Test
    public void test0695() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0695");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-79122.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-497138.1878746632d) + "'", double1 == (-497138.1878746632d));
    }

    @Test
    public void test0696() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0696");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(46750.0f, 163334.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 420168.0f + "'", float2 == 420168.0f);
    }

    @Test
    public void test0697() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0697");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2439627.0f, (-1.27959576E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.51039904E8f) + "'", float2 == (-2.51039904E8f));
    }

    @Test
    public void test0698() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0698");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-483300.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 483300.0f + "'", float2 == 483300.0f);
    }

    @Test
    public void test0699() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0699");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-66172.0f), (-39515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-211374.0f) + "'", float2 == (-211374.0f));
    }

    @Test
    public void test0700() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0700");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 537271.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.2115288E7f + "'", float2 == 5.2115288E7f);
    }

    @Test
    public void test0701() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0701");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1008802.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0702() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0702");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(80268.0f, 844.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 162224.0f + "'", float2 == 162224.0f);
    }

    @Test
    public void test0703() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0703");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(480926.0f, 83494.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1128840.0f + "'", float2 == 1128840.0f);
    }

    @Test
    public void test0704() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0704");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 42097.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-42097.0f) + "'", float2 == (-42097.0f));
    }

    @Test
    public void test0705() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0705");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 5480.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5480.0f) + "'", float2 == (-5480.0f));
    }

    @Test
    public void test0706() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0706");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) '#', 5818962.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1637994E7f + "'", float2 == 1.1637994E7f);
    }

    @Test
    public void test0707() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0707");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1435699.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2871398.0f + "'", float2 == 2871398.0f);
    }

    @Test
    public void test0708() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0708");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-4940.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4940.0f) + "'", float2 == (-4940.0f));
    }

    @Test
    public void test0709() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0709");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (float) (-1));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test0710() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0710");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-39530.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3953000.0f) + "'", float2 == (-3953000.0f));
    }

    @Test
    public void test0711() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0711");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1854835.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1654272019242449E7d + "'", double1 == 1.1654272019242449E7d);
    }

    @Test
    public void test0712() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0712");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 105821.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0713() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0713");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-68.0f), 303922.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 607708.0f + "'", float2 == 607708.0f);
    }

    @Test
    public void test0714() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0714");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-88.0f), 135000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 269824.0f + "'", float2 == 269824.0f);
    }

    @Test
    public void test0715() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0715");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 843.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8430.0f + "'", float2 == 8430.0f);
    }

    @Test
    public void test0716() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0716");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(886312.0f, 480926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2734476.0f + "'", float2 == 2734476.0f);
    }

    @Test
    public void test0717() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0717");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.562664E8f, 158368.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.12849536E8f + "'", float2 == 5.12849536E8f);
    }

    @Test
    public void test0718() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0718");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 4724.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9448.0f + "'", float2 == 9448.0f);
    }

    @Test
    public void test0719() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0719");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(178809.0f, (-4.11109248E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.2186086E8f) + "'", float2 == (-8.2186086E8f));
    }

    @Test
    public void test0720() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0720");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 304064.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3040640.0f + "'", float2 == 3040640.0f);
    }

    @Test
    public void test0721() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0721");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 2860396.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2860396.0f) + "'", float2 == (-2860396.0f));
    }

    @Test
    public void test0722() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0722");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-399330.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2509064.3887160243d) + "'", double1 == (-2509064.3887160243d));
    }

    @Test
    public void test0723() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0723");
        double double1 = org.example.maths.Perimeter.perimeterCircle(306996.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1928912.7565629042d + "'", double1 == 1928912.7565629042d);
    }

    @Test
    public void test0724() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0724");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 94196.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0725() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0725");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 10100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 101000.0f + "'", float2 == 101000.0f);
    }

    @Test
    public void test0726() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0726");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-852.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5353.2738817170075d) + "'", double1 == (-5353.2738817170075d));
    }

    @Test
    public void test0727() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0727");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(10531.0f, 889760.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1800582.0f + "'", float2 == 1800582.0f);
    }

    @Test
    public void test0728() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0728");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 26.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0729() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0729");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 196059.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 196059.0f + "'", float2 == 196059.0f);
    }

    @Test
    public void test0730() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0730");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4958.0f, (-7642758.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.52756E7f) + "'", float2 == (-1.52756E7f));
    }

    @Test
    public void test0731() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0731");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41496.0f, 1200080.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2483152.0f + "'", float2 == 2483152.0f);
    }

    @Test
    public void test0732() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0732");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(26.0f, (-0.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 52.0f + "'", float2 == 52.0f);
    }

    @Test
    public void test0733() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0733");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(16.0f, 222397.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 444826.0f + "'", float2 == 444826.0f);
    }

    @Test
    public void test0734() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0734");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 1.279548E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.24116152E10f + "'", float2 == 1.24116152E10f);
    }

    @Test
    public void test0735() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0735");
        double double1 = org.example.maths.Perimeter.perimeterCircle(170720.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1072665.395641699d + "'", double1 == 1072665.395641699d);
    }

    @Test
    public void test0736() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0736");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-2860396.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.860396E7f) + "'", float2 == (-2.860396E7f));
    }

    @Test
    public void test0737() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0737");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-97.0f), (-4111120.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8222434.0f) + "'", float2 == (-8222434.0f));
    }

    @Test
    public void test0738() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0738");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 76567.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 76567.0f + "'", float2 == 76567.0f);
    }

    @Test
    public void test0739() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0739");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 3433986.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.3309664E8f + "'", float2 == 3.3309664E8f);
    }

    @Test
    public void test0740() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0740");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(48960.0f, 85664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 269248.0f + "'", float2 == 269248.0f);
    }

    @Test
    public void test0741() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0741");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 1.7501904E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7501904E7f + "'", float2 == 1.7501904E7f);
    }

    @Test
    public void test0742() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0742");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 549548.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 549548.0f + "'", float2 == 549548.0f);
    }

    @Test
    public void test0743() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0743");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 4462487.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4462487.0f + "'", float2 == 4462487.0f);
    }

    @Test
    public void test0744() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0744");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(45784.0f, 15.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 91598.0f + "'", float2 == 91598.0f);
    }

    @Test
    public void test0745() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0745");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 776.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0746() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0746");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-14890.0f), 1480.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-26820.0f) + "'", float2 == (-26820.0f));
    }

    @Test
    public void test0747() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0747");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 1, 359378.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 718758.0f + "'", float2 == 718758.0f);
    }

    @Test
    public void test0748() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0748");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.4663296E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.213220598202519E7d + "'", double1 == 9.213220598202519E7d);
    }

    @Test
    public void test0749() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0749");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2020.0f, 117592.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 239224.0f + "'", float2 == 239224.0f);
    }

    @Test
    public void test0750() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0750");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-36.0f), 590839.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1181606.0f + "'", float2 == 1181606.0f);
    }

    @Test
    public void test0751() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0751");
        double double1 = org.example.maths.Perimeter.perimeterCircle(124931.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 784964.6236112529d + "'", double1 == 784964.6236112529d);
    }

    @Test
    public void test0752() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0752");
        double double1 = org.example.maths.Perimeter.perimeterCircle(663898.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4171394.159065913d + "'", double1 == 4171394.159065913d);
    }

    @Test
    public void test0753() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0753");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-14890.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0754() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0754");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 2328718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.4518976E7f + "'", float2 == 7.4518976E7f);
    }

    @Test
    public void test0755() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0755");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 80911.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 809110.0f + "'", float2 == 809110.0f);
    }

    @Test
    public void test0756() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0756");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 86076.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 172152.0f + "'", float2 == 172152.0f);
    }

    @Test
    public void test0757() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0757");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-229267.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2292670.0f) + "'", float2 == (-2292670.0f));
    }

    @Test
    public void test0758() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0758");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-1150826.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.150826E8f) + "'", float2 == (-1.150826E8f));
    }

    @Test
    public void test0759() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0759");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 131775.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4612125.0f + "'", float2 == 4612125.0f);
    }

    @Test
    public void test0760() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0760");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-37192.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0761() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0761");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 340.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 680.0f + "'", float2 == 680.0f);
    }

    @Test
    public void test0762() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0762");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(483300.0f, 1433970.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3834540.0f + "'", float2 == 3834540.0f);
    }

    @Test
    public void test0763() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0763");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (float) (short) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.0f) + "'", float2 == (-1.0f));
    }

    @Test
    public void test0764() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0764");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.264892E7f), 151168.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.4995504E7f) + "'", float2 == (-4.4995504E7f));
    }

    @Test
    public void test0765() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0765");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2352.0f, (-66.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4572.0f + "'", float2 == 4572.0f);
    }

    @Test
    public void test0766() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0766");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 1.2625512E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2625512E8f + "'", float2 == 1.2625512E8f);
    }

    @Test
    public void test0767() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0767");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-9920.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-962240.0f) + "'", float2 == (-962240.0f));
    }

    @Test
    public void test0768() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0768");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21400.0f, (-5626.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 31548.0f + "'", float2 == 31548.0f);
    }

    @Test
    public void test0769() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0769");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 85664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8309408.0f + "'", float2 == 8309408.0f);
    }

    @Test
    public void test0770() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0770");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-17284.0f), (-5.9842952E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.19720472E8f) + "'", float2 == (-1.19720472E8f));
    }

    @Test
    public void test0771() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0771");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9076.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 57026.18984796193d + "'", double1 == 57026.18984796193d);
    }

    @Test
    public void test0772() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0772");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-9920.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9920.0f + "'", float2 == 9920.0f);
    }

    @Test
    public void test0773() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0773");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2206.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 13860.706787638168d + "'", double1 == 13860.706787638168d);
    }

    @Test
    public void test0774() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0774");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.10908928E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.3251798775625973E9d) + "'", double1 == (-1.3251798775625973E9d));
    }

    @Test
    public void test0775() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0775");
        double double1 = org.example.maths.Perimeter.perimeterCircle(809110.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5083788.063892075d + "'", double1 == 5083788.063892075d);
    }

    @Test
    public void test0776() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0776");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 86064.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 86064.0f + "'", float2 == 86064.0f);
    }

    @Test
    public void test0777() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0777");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.05555968E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.2915462379406772E9d) + "'", double1 == (-1.2915462379406772E9d));
    }

    @Test
    public void test0778() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0778");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3986224.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.5046184067926638E7d + "'", double1 == 2.5046184067926638E7d);
    }

    @Test
    public void test0779() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0779");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(889760.0f, 5226.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1789972.0f + "'", float2 == 1789972.0f);
    }

    @Test
    public void test0780() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0780");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.264892E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4230736136748588E8d) + "'", double1 == (-1.4230736136748588E8d));
    }

    @Test
    public void test0781() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0781");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20800.0f + "'", float2 == 20800.0f);
    }

    @Test
    public void test0782() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0782");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(196059.0f, 158.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 392434.0f + "'", float2 == 392434.0f);
    }

    @Test
    public void test0783() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0783");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.5716136E7f, 15211.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1462696E7f + "'", float2 == 5.1462696E7f);
    }

    @Test
    public void test0784() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0784");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-42097.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1473395.0f) + "'", float2 == (-1473395.0f));
    }

    @Test
    public void test0785() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0785");
        double double1 = org.example.maths.Perimeter.perimeterCircle(81687.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 513254.55818757886d + "'", double1 == 513254.55818757886d);
    }

    @Test
    public void test0786() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0786");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 2304000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2304000.0f) + "'", float2 == (-2304000.0f));
    }

    @Test
    public void test0787() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0787");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(38473.0f, 359378.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 795702.0f + "'", float2 == 795702.0f);
    }

    @Test
    public void test0788() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0788");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.4663296E7f, 260.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.9327112E7f + "'", float2 == 2.9327112E7f);
    }

    @Test
    public void test0789() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0789");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(158.0f, (-1217.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2118.0f) + "'", float2 == (-2118.0f));
    }

    @Test
    public void test0790() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0790");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5226.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 32835.926415320515d + "'", double1 == 32835.926415320515d);
    }

    @Test
    public void test0791() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0791");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 472.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-472.0f) + "'", float2 == (-472.0f));
    }

    @Test
    public void test0792() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0792");
        double double1 = org.example.maths.Perimeter.perimeterCircle(151168.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 949816.5565157237d + "'", double1 == 949816.5565157237d);
    }

    @Test
    public void test0793() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0793");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 232.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8120.0f + "'", float2 == 8120.0f);
    }

    @Test
    public void test0794() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0794");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 10, 2235184.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4470388.0f + "'", float2 == 4470388.0f);
    }

    @Test
    public void test0795() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0795");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-1217.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1217.0f + "'", float2 == 1217.0f);
    }

    @Test
    public void test0796() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0796");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1664.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 10455.220351146832d + "'", double1 == 10455.220351146832d);
    }

    @Test
    public void test0797() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0797");
        double double1 = org.example.maths.Perimeter.perimeterCircle(230228.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1446565.186901342d + "'", double1 == 1446565.186901342d);
    }

    @Test
    public void test0798() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0798");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9382464.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.895175994994141E7d + "'", double1 == 5.895175994994141E7d);
    }

    @Test
    public void test0799() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0799");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2202.0f, (-66172.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-127940.0f) + "'", float2 == (-127940.0f));
    }

    @Test
    public void test0800() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0800");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1384.0f, 303430.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 609628.0f + "'", float2 == 609628.0f);
    }

    @Test
    public void test0801() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0801");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(92842.0f, 1217.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 188118.0f + "'", float2 == 188118.0f);
    }

    @Test
    public void test0802() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0802");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-66.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-414.6902302738527d) + "'", double1 == (-414.6902302738527d));
    }

    @Test
    public void test0803() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0803");
        double double1 = org.example.maths.Perimeter.perimeterCircle(292252.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1836273.4723938485d + "'", double1 == 1836273.4723938485d);
    }

    @Test
    public void test0804() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0804");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1811572.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.340502E7f + "'", float2 == 6.340502E7f);
    }

    @Test
    public void test0805() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0805");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19800.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-39600.0f) + "'", float2 == (-39600.0f));
    }

    @Test
    public void test0806() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0806");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 2867216.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.0035256E8f + "'", float2 == 1.0035256E8f);
    }

    @Test
    public void test0807() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0807");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8599725.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.4033665765784964E7d + "'", double1 == 5.4033665765784964E7d);
    }

    @Test
    public void test0808() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0808");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 5.2115288E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0809() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0809");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(382172.0f, (-67242.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 629860.0f + "'", float2 == 629860.0f);
    }

    @Test
    public void test0810() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0810");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 429320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.373824E7f + "'", float2 == 1.373824E7f);
    }

    @Test
    public void test0811() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0811");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 795702.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0812() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0812");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 1677285.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1677285.0f + "'", float2 == 1677285.0f);
    }

    @Test
    public void test0813() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0813");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-1.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0814() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0814");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 1279548.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1279548.0f + "'", float2 == 1279548.0f);
    }

    @Test
    public void test0815() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0815");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 607708.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 607708.0f + "'", float2 == 607708.0f);
    }

    @Test
    public void test0816() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0816");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-58.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1856.0f) + "'", float2 == (-1856.0f));
    }

    @Test
    public void test0817() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0817");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(166025.0f, (-4.11109248E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.2188646E8f) + "'", float2 == (-8.2188646E8f));
    }

    @Test
    public void test0818() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0818");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 230400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.304E7f + "'", float2 == 2.304E7f);
    }

    @Test
    public void test0819() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0819");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.28999976E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.105307538297193E8d + "'", double1 == 8.105307538297193E8d);
    }

    @Test
    public void test0820() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0820");
        double double1 = org.example.maths.Perimeter.perimeterCircle(20198.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 126907.77683441328d + "'", double1 == 126907.77683441328d);
    }

    @Test
    public void test0821() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0821");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-48760.0f), 50132.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2744.0f + "'", float2 == 2744.0f);
    }

    @Test
    public void test0822() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0822");
        double double1 = org.example.maths.Perimeter.perimeterCircle(188118.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1181980.2536160094d + "'", double1 == 1181980.2536160094d);
    }

    @Test
    public void test0823() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0823");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-10.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test0824() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0824");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-92668.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-582250.2160457179d) + "'", double1 == (-582250.2160457179d));
    }

    @Test
    public void test0825() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0825");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 17000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-17000.0f) + "'", float2 == (-17000.0f));
    }

    @Test
    public void test0826() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0826");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4470388.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.8088276198991936E7d + "'", double1 == 2.8088276198991936E7d);
    }

    @Test
    public void test0827() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0827");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(138775.0f, (-2860396.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5443242.0f) + "'", float2 == (-5443242.0f));
    }

    @Test
    public void test0828() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0828");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 680.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6800.0f + "'", float2 == 6800.0f);
    }

    @Test
    public void test0829() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0829");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 160926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 160926.0f + "'", float2 == 160926.0f);
    }

    @Test
    public void test0830() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0830");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 310038.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.10038E7f + "'", float2 == 3.10038E7f);
    }

    @Test
    public void test0831() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0831");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-5.9805456E7f), 267759.0f, 220.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0832() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0832");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 48960.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0833() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0833");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(180543.0f, 489806.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1340698.0f + "'", float2 == 1340698.0f);
    }

    @Test
    public void test0834() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0834");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1479881.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9298366.555574233d + "'", double1 == 9298366.555574233d);
    }

    @Test
    public void test0835() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0835");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 2851037.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0836() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0836");
        double double1 = org.example.maths.Perimeter.perimeterCircle(780616.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4904754.9817493d + "'", double1 == 4904754.9817493d);
    }

    @Test
    public void test0837() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0837");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20768.0f, 241502.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 524540.0f + "'", float2 == 524540.0f);
    }

    @Test
    public void test0838() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0838");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 200474.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0839() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0839");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1425600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.9896E7f + "'", float2 == 4.9896E7f);
    }

    @Test
    public void test0840() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0840");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1120.0f, (-5387.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8534.0f) + "'", float2 == (-8534.0f));
    }

    @Test
    public void test0841() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0841");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-97.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-609.4689747964198d) + "'", double1 == (-609.4689747964198d));
    }

    @Test
    public void test0842() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0842");
        double double1 = org.example.maths.Perimeter.perimeterCircle(944115.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5932049.496287855d + "'", double1 == 5932049.496287855d);
    }

    @Test
    public void test0843() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0843");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-19820.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0844() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0844");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2792.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 17542.653377645405d + "'", double1 == 17542.653377645405d);
    }

    @Test
    public void test0845() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0845");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(888311.0f, (float) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1776624.0f + "'", float2 == 1776624.0f);
    }

    @Test
    public void test0846() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0846");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 48960.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 489600.0f + "'", float2 == 489600.0f);
    }

    @Test
    public void test0847() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0847");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 407543.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 815086.0f + "'", float2 == 815086.0f);
    }

    @Test
    public void test0848() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0848");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(144742.0f, 653984.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1597452.0f + "'", float2 == 1597452.0f);
    }

    @Test
    public void test0849() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0849");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-66172.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-415770.9381466876d) + "'", double1 == (-415770.9381466876d));
    }

    @Test
    public void test0850() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0850");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-472.0f), 122897.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 244850.0f + "'", float2 == 244850.0f);
    }

    @Test
    public void test0851() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0851");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3434140.0f, 180432.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7229144.0f + "'", float2 == 7229144.0f);
    }

    @Test
    public void test0852() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0852");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4598.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 28890.086042411738d + "'", double1 == 28890.086042411738d);
    }

    @Test
    public void test0853() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0853");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(178809.0f, 100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 357818.0f + "'", float2 == 357818.0f);
    }

    @Test
    public void test0854() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0854");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8309408.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.220955025696051E7d + "'", double1 == 5.220955025696051E7d);
    }

    @Test
    public void test0855() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0855");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-402720.0f), 42832.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-719776.0f) + "'", float2 == (-719776.0f));
    }

    @Test
    public void test0856() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0856");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 372976.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.72976E7f + "'", float2 == 3.72976E7f);
    }

    @Test
    public void test0857() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0857");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(886312.0f, 85856.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1944336.0f + "'", float2 == 1944336.0f);
    }

    @Test
    public void test0858() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0858");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-76390.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-479972.5256154486d) + "'", double1 == (-479972.5256154486d));
    }

    @Test
    public void test0859() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0859");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(188118.0f, 524540.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1425316.0f + "'", float2 == 1425316.0f);
    }

    @Test
    public void test0860() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0860");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 21470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2147000.0f + "'", float2 == 2147000.0f);
    }

    @Test
    public void test0861() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0861");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.563036E8f), 280885.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.1204544E8f) + "'", float2 == (-3.1204544E8f));
    }

    @Test
    public void test0862() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0862");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 2744.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 266168.0f + "'", float2 == 266168.0f);
    }

    @Test
    public void test0863() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0863");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 29188.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 291880.0f + "'", float2 == 291880.0f);
    }

    @Test
    public void test0864() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0864");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-438.0f), 358002.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 715128.0f + "'", float2 == 715128.0f);
    }

    @Test
    public void test0865() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0865");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.9896E7f, 738.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.9793472E7f + "'", float2 == 9.9793472E7f);
    }

    @Test
    public void test0866() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0866");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, (-719776.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-719776.0f) + "'", float2 == (-719776.0f));
    }

    @Test
    public void test0867() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0867");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6884.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 43253.44765462427d + "'", double1 == 43253.44765462427d);
    }

    @Test
    public void test0868() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0868");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3340.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 20985.838925979817d + "'", double1 == 20985.838925979817d);
    }

    @Test
    public void test0869() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0869");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(48672.0f, 663898.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1425140.0f + "'", float2 == 1425140.0f);
    }

    @Test
    public void test0870() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0870");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 2780.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 278000.0f + "'", float2 == 278000.0f);
    }

    @Test
    public void test0871() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0871");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-7816300.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0872() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0872");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.562664E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6101692792038066E9d + "'", double1 == 1.6101692792038066E9d);
    }

    @Test
    public void test0873() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0873");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(417693.0f, 9.9793472E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.00422336E8f + "'", float2 == 2.00422336E8f);
    }

    @Test
    public void test0874() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0874");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.26698008E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.960670623145217E8d + "'", double1 == 7.960670623145217E8d);
    }

    @Test
    public void test0875() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0875");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(87220.0f, 652.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 175744.0f + "'", float2 == 175744.0f);
    }

    @Test
    public void test0876() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0876");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(590839.0f, 7891415.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.6964508E7f + "'", float2 == 1.6964508E7f);
    }

    @Test
    public void test0877() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0877");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-74.0f), 21470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42792.0f + "'", float2 == 42792.0f);
    }

    @Test
    public void test0878() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0878");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 3433986.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.78567264E8f + "'", float2 == 1.78567264E8f);
    }

    @Test
    public void test0879() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0879");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 2352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 23520.0f + "'", float2 == 23520.0f);
    }

    @Test
    public void test0880() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0880");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 1, 39840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 79682.0f + "'", float2 == 79682.0f);
    }

    @Test
    public void test0881() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0881");
        double double1 = org.example.maths.Perimeter.perimeterCircle(648960.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4077535.9369472642d + "'", double1 == 4077535.9369472642d);
    }

    @Test
    public void test0882() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0882");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 3.10038E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0883() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0883");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-42.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-263.89378290154264d) + "'", double1 == (-263.89378290154264d));
    }

    @Test
    public void test0884() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0884");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(269824.0f, (-7703000.0f), (-76390.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0885() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0885");
        double double1 = org.example.maths.Perimeter.perimeterCircle(42798.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 268907.76477667195d + "'", double1 == 268907.76477667195d);
    }

    @Test
    public void test0886() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0886");
        double double1 = org.example.maths.Perimeter.perimeterCircle(609628.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3830405.692445277d + "'", double1 == 3830405.692445277d);
    }

    @Test
    public void test0887() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0887");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(1.27973919E10f, 81687.0f, 93500.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0888() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0888");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 2304000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0889() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0889");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 46.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 46.0f + "'", float2 == 46.0f);
    }

    @Test
    public void test0890() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0890");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(116018.0f, (-4056330.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7880624.0f) + "'", float2 == (-7880624.0f));
    }

    @Test
    public void test0891() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0891");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 92842.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2970944.0f + "'", float2 == 2970944.0f);
    }

    @Test
    public void test0892() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0892");
        double double1 = org.example.maths.Perimeter.perimeterCircle(607708.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3818341.976655492d + "'", double1 == 3818341.976655492d);
    }

    @Test
    public void test0893() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0893");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, (-74904.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-74904.0f) + "'", float2 == (-74904.0f));
    }

    @Test
    public void test0894() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0894");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1856.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-11661.591930125313d) + "'", double1 == (-11661.591930125313d));
    }

    @Test
    public void test0895() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0895");
        double double1 = org.example.maths.Perimeter.perimeterCircle(222397.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1397361.5627608185d + "'", double1 == 1397361.5627608185d);
    }

    @Test
    public void test0896() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0896");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21133.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42266.0f + "'", float2 == 42266.0f);
    }

    @Test
    public void test0897() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0897");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 68190.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0898() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0898");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(10531.0f, 1.60946E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.2210262E7f + "'", float2 == 3.2210262E7f);
    }

    @Test
    public void test0899() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0899");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9700.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 60946.897479641986d + "'", double1 == 60946.897479641986d);
    }

    @Test
    public void test0900() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0900");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 2320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2320.0f) + "'", float2 == (-2320.0f));
    }

    @Test
    public void test0901() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0901");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1279415.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0902() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0902");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 9076.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 907600.0f + "'", float2 == 907600.0f);
    }

    @Test
    public void test0903() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0903");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 160946.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0904() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0904");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0905() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0905");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-2.860396E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.86039616E8f) + "'", float2 == (-2.86039616E8f));
    }

    @Test
    public void test0906() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0906");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 3449.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3449.0f + "'", float2 == 3449.0f);
    }

    @Test
    public void test0907() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0907");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(175126.0f, 20280.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 390812.0f + "'", float2 == 390812.0f);
    }

    @Test
    public void test0908() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0908");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 10531.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1053100.0f + "'", float2 == 1053100.0f);
    }

    @Test
    public void test0909() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0909");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2860396.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.797239811991526E7d) + "'", double1 == (-1.797239811991526E7d));
    }

    @Test
    public void test0910() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0910");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-71934.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-451974.65188665636d) + "'", double1 == (-451974.65188665636d));
    }

    @Test
    public void test0911() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0911");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-188545.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 188545.0f + "'", float2 == 188545.0f);
    }

    @Test
    public void test0912() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0912");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14305.0f, 429361.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 887332.0f + "'", float2 == 887332.0f);
    }

    @Test
    public void test0913() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0913");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8422.0f, (-38.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 16768.0f + "'", float2 == 16768.0f);
    }

    @Test
    public void test0914() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0914");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 8309408.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8309408.0f + "'", float2 == 8309408.0f);
    }

    @Test
    public void test0915() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0915");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 5.12849536E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.12849536E8f + "'", float2 == 5.12849536E8f);
    }

    @Test
    public void test0916() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0916");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5.970514E7f), (-1.563036E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.50671008E8f) + "'", float2 == (-1.50671008E8f));
    }

    @Test
    public void test0917() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0917");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(526660.0f, 9920.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1073160.0f + "'", float2 == 1073160.0f);
    }

    @Test
    public void test0918() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0918");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-21593.0f), 220.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-42746.0f) + "'", float2 == (-42746.0f));
    }

    @Test
    public void test0919() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0919");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20768.0f, (-30.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 41476.0f + "'", float2 == 41476.0f);
    }

    @Test
    public void test0920() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0920");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1200080.0f, 179000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2758160.0f + "'", float2 == 2758160.0f);
    }

    @Test
    public void test0921() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0921");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-1473395.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.47339504E8f) + "'", float2 == (-1.47339504E8f));
    }

    @Test
    public void test0922() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0922");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(43712.0f, 303430.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 694284.0f + "'", float2 == 694284.0f);
    }

    @Test
    public void test0923() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0923");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 6.340502E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.02896064E9f + "'", float2 == 2.02896064E9f);
    }

    @Test
    public void test0924() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0924");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 369712.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-369712.0f) + "'", float2 == (-369712.0f));
    }

    @Test
    public void test0925() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0925");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(15.0f, 1338720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2677470.0f + "'", float2 == 2677470.0f);
    }

    @Test
    public void test0926() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0926");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.0f), 2646.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5290.0f + "'", float2 == 5290.0f);
    }

    @Test
    public void test0927() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0927");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-36.0f), 1352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2632.0f + "'", float2 == 2632.0f);
    }

    @Test
    public void test0928() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0928");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(77268.0f, 1696240.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3547016.0f + "'", float2 == 3547016.0f);
    }

    @Test
    public void test0929() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0929");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-385150.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.8515E7f) + "'", float2 == (-3.8515E7f));
    }

    @Test
    public void test0930() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0930");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.27964392E8f, 46750.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.56022288E8f + "'", float2 == 2.56022288E8f);
    }

    @Test
    public void test0931() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0931");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2252032.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4504064.0f) + "'", float2 == (-4504064.0f));
    }

    @Test
    public void test0932() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0932");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1433970.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9009899.234936312d + "'", double1 == 9009899.234936312d);
    }

    @Test
    public void test0933() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0933");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 421537.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0934() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0934");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9805.0f, 888126.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1795862.0f + "'", float2 == 1795862.0f);
    }

    @Test
    public void test0935() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0935");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 79130.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7913000.0f + "'", float2 == 7913000.0f);
    }

    @Test
    public void test0936() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0936");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-29.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-182.212373908208d) + "'", double1 == (-182.212373908208d));
    }

    @Test
    public void test0937() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0937");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 45784.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2380768.0f + "'", float2 == 2380768.0f);
    }

    @Test
    public void test0938() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0938");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.563036E8f), 2538165.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.0753088E8f) + "'", float2 == (-3.0753088E8f));
    }

    @Test
    public void test0939() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0939");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.27973919E10f, (-8.2188646E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.39510118E10f + "'", float2 == 2.39510118E10f);
    }

    @Test
    public void test0940() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0940");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5.28825376E8f, 20280.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.05769133E9f + "'", float2 == 1.05769133E9f);
    }

    @Test
    public void test0941() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0941");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.49876608E8f), 382172.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.98988864E8f) + "'", float2 == (-2.98988864E8f));
    }

    @Test
    public void test0942() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0942");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(489600.0f, 1846426.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4672052.0f + "'", float2 == 4672052.0f);
    }

    @Test
    public void test0943() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0943");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-39530.0f), 69.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-78922.0f) + "'", float2 == (-78922.0f));
    }

    @Test
    public void test0944() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0944");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2118.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-13307.786480606364d) + "'", double1 == (-13307.786480606364d));
    }

    @Test
    public void test0945() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0945");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.8515E7f), 6638.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.701672E7f) + "'", float2 == (-7.701672E7f));
    }

    @Test
    public void test0946() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0946");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(19468.0f, 4404608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8848152.0f + "'", float2 == 8848152.0f);
    }

    @Test
    public void test0947() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0947");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(715128.0f, 556283.0f, 958511.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test0948() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0948");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(244850.0f, 291880.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1073460.0f + "'", float2 == 1073460.0f);
    }

    @Test
    public void test0949() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0949");
        double double1 = org.example.maths.Perimeter.perimeterCircle(887332.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5575271.384990277d + "'", double1 == 5575271.384990277d);
    }

    @Test
    public void test0950() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0950");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(478404.0f, 18.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 956844.0f + "'", float2 == 956844.0f);
    }

    @Test
    public void test0951() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0951");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.56022288E8f, (-39600.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.11965376E8f + "'", float2 == 5.11965376E8f);
    }

    @Test
    public void test0952() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0952");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.27973919E10f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.040838458036986E10d + "'", double1 == 8.040838458036986E10d);
    }

    @Test
    public void test0953() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0953");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 5945390.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.189078E7f + "'", float2 == 1.189078E7f);
    }

    @Test
    public void test0954() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0954");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8120.0f, (-192.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 15856.0f + "'", float2 == 15856.0f);
    }

    @Test
    public void test0955() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0955");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-193.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-19300.0f) + "'", float2 == (-19300.0f));
    }

    @Test
    public void test0956() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0956");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1343.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-8438.317867542184d) + "'", double1 == (-8438.317867542184d));
    }

    @Test
    public void test0957() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0957");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(17020.0f, (-1.19720472E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.39406912E8f) + "'", float2 == (-2.39406912E8f));
    }

    @Test
    public void test0958() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0958");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 291968.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.91968E7f + "'", float2 == 2.91968E7f);
    }

    @Test
    public void test0959() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0959");
        double double1 = org.example.maths.Perimeter.perimeterCircle(89756.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 563953.5804312109d + "'", double1 == 563953.5804312109d);
    }

    @Test
    public void test0960() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0960");
        double double1 = org.example.maths.Perimeter.perimeterCircle(214.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1344.6016557364314d + "'", double1 == 1344.6016557364314d);
    }

    @Test
    public void test0961() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0961");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4400194.0f, 42980.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8886348.0f + "'", float2 == 8886348.0f);
    }

    @Test
    public void test0962() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0962");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-17284.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test0963() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0963");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 79130.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4114760.0f + "'", float2 == 4114760.0f);
    }

    @Test
    public void test0964() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0964");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(429197.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 858394.0f + "'", float2 == 858394.0f);
    }

    @Test
    public void test0965() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0965");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8863120.0f, (-7772656.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2180928.0f + "'", float2 == 2180928.0f);
    }

    @Test
    public void test0966() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0966");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 6.3190616E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.3190616E7f + "'", float2 == 6.3190616E7f);
    }

    @Test
    public void test0967() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0967");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 4000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8000.0f + "'", float2 == 8000.0f);
    }

    @Test
    public void test0968() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0968");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0969() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0969");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 57991.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0970() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0970");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2744.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 17241.060482900786d + "'", double1 == 17241.060482900786d);
    }

    @Test
    public void test0971() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0971");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 19398.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1939800.0f + "'", float2 == 1939800.0f);
    }

    @Test
    public void test0972() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0972");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(171710.0f, 8599725.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.754287E7f + "'", float2 == 1.754287E7f);
    }

    @Test
    public void test0973() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0973");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 858394.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0974() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0974");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.05293424E8f), 1033946.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.08518944E8f) + "'", float2 == (-4.08518944E8f));
    }

    @Test
    public void test0975() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0975");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5387.0f, 392434.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 795642.0f + "'", float2 == 795642.0f);
    }

    @Test
    public void test0976() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0976");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1338720.0f, 232985.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3143410.0f + "'", float2 == 3143410.0f);
    }

    @Test
    public void test0977() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0977");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.56022288E8f, 136.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.12044864E8f + "'", float2 == 5.12044864E8f);
    }

    @Test
    public void test0978() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0978");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(39530.0f, (float) (short) 0);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 79060.0f + "'", float2 == 79060.0f);
    }

    @Test
    public void test0979() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0979");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(242989.0f, 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 486110.0f + "'", float2 == 486110.0f);
    }

    @Test
    public void test0980() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0980");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1364906.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1364906.0f + "'", float2 == 1364906.0f);
    }

    @Test
    public void test0981() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0981");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-52861.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-332135.4585228201d) + "'", double1 == (-332135.4585228201d));
    }

    @Test
    public void test0982() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0982");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 41835.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 418350.0f + "'", float2 == 418350.0f);
    }

    @Test
    public void test0983() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0983");
        double double1 = org.example.maths.Perimeter.perimeterCircle(166025.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1043165.8406244908d + "'", double1 == 1043165.8406244908d);
    }

    @Test
    public void test0984() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0984");
        double double1 = org.example.maths.Perimeter.perimeterCircle(68190.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 428450.40609657596d + "'", double1 == 428450.40609657596d);
    }

    @Test
    public void test0985() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0985");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2206.0f, (-124931.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-245450.0f) + "'", float2 == (-245450.0f));
    }

    @Test
    public void test0986() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0986");
        double double1 = org.example.maths.Perimeter.perimeterCircle(801055.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5033177.006242744d + "'", double1 == 5033177.006242744d);
    }

    @Test
    public void test0987() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0987");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2328718.0f, (-472.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4656492.0f + "'", float2 == 4656492.0f);
    }

    @Test
    public void test0988() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0988");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.1202344E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.9605010937036312E8d) + "'", double1 == (-1.9605010937036312E8d));
    }

    @Test
    public void test0989() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0989");
        double double1 = org.example.maths.Perimeter.perimeterCircle(346338.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2176105.8329179636d + "'", double1 == 2176105.8329179636d);
    }

    @Test
    public void test0990() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0990");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.50671008E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-9.466938636835378E8d) + "'", double1 == (-9.466938636835378E8d));
    }

    @Test
    public void test0991() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0991");
        double double1 = org.example.maths.Perimeter.perimeterCircle(138775.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 871949.041003847d + "'", double1 == 871949.041003847d);
    }

    @Test
    public void test0992() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0992");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 158368.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 158368.0f + "'", float2 == 158368.0f);
    }

    @Test
    public void test0993() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0993");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1053100.0f, 2028300.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6162800.0f + "'", float2 == 6162800.0f);
    }

    @Test
    public void test0994() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0994");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 3986224.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.27559168E8f + "'", float2 == 1.27559168E8f);
    }

    @Test
    public void test0995() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0995");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41835.0f, 1846426.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3776522.0f + "'", float2 == 3776522.0f);
    }

    @Test
    public void test0996() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0996");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 815086.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8150860.0f + "'", float2 == 8150860.0f);
    }

    @Test
    public void test0997() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0997");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1696240.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test0998() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0998");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4.9896E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.135058140870326E8d + "'", double1 == 3.135058140870326E8d);
    }

    @Test
    public void test0999() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test0999");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-100.0f) + "'", float2 == (-100.0f));
    }

    @Test
    public void test1000() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1000");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 4572.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9144.0f + "'", float2 == 9144.0f);
    }

    @Test
    public void test1001() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1001");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(306996.0f, (-2.05293424E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.09972864E8f) + "'", float2 == (-4.09972864E8f));
    }

    @Test
    public void test1002() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1002");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-150.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-14550.0f) + "'", float2 == (-14550.0f));
    }

    @Test
    public void test1003() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1003");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(79130.0f, 2439627.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5037514.0f + "'", float2 == 5037514.0f);
    }

    @Test
    public void test1004() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1004");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(88576.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 177152.0f + "'", float2 == 177152.0f);
    }

    @Test
    public void test1005() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1005");
        double double1 = org.example.maths.Perimeter.perimeterCircle(985888.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6194516.996124668d + "'", double1 == 6194516.996124668d);
    }

    @Test
    public void test1006() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1006");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 1.373824E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.373824E7f + "'", float2 == 1.373824E7f);
    }

    @Test
    public void test1007() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1007");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.9327112E7f, 186445.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.9027112E7f + "'", float2 == 5.9027112E7f);
    }

    @Test
    public void test1008() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1008");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(9076.0f, (-2320.0f), (-4111120.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1009() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1009");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 364752.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.64752E7f + "'", float2 == 3.64752E7f);
    }

    @Test
    public void test1010() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1010");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-38515.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-241996.88210602177d) + "'", double1 == (-241996.88210602177d));
    }

    @Test
    public void test1011() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1011");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-26.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-163.36281798666926d) + "'", double1 == (-163.36281798666926d));
    }

    @Test
    public void test1012() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1012");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 217136.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2171360.0f + "'", float2 == 2171360.0f);
    }

    @Test
    public void test1013() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1013");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9700.0f, 42192.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 103784.0f + "'", float2 == 103784.0f);
    }

    @Test
    public void test1014() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1014");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 182592.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1015() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1015");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(19840.0f, (-28799.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-17918.0f) + "'", float2 == (-17918.0f));
    }

    @Test
    public void test1016() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1016");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 0, 9352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 18704.0f + "'", float2 == 18704.0f);
    }

    @Test
    public void test1017() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1017");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(718758.0f, (-140752.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1156012.0f + "'", float2 == 1156012.0f);
    }

    @Test
    public void test1018() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1018");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-21593.0f), 2871398.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5699610.0f + "'", float2 == 5699610.0f);
    }

    @Test
    public void test1019() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1019");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 1.8621926E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.8621926E7f) + "'", float2 == (-1.8621926E7f));
    }

    @Test
    public void test1020() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1020");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21856.0f, 3340.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 50392.0f + "'", float2 == 50392.0f);
    }

    @Test
    public void test1021() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1021");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(359378.0f, 738.0f, 1.2625512E8f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1022() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1022");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1128840.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7092710.902156604d + "'", double1 == 7092710.902156604d);
    }

    @Test
    public void test1023() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1023");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-44.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-44.0f) + "'", float2 == (-44.0f));
    }

    @Test
    public void test1024() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1024");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3040640.0f, 46.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6081372.0f + "'", float2 == 6081372.0f);
    }

    @Test
    public void test1025() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1025");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(2880875.0f, 505770.0f, (float) ' ', floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1026() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1026");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(19697.0f, 180432.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 400258.0f + "'", float2 == 400258.0f);
    }

    @Test
    public void test1027() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1027");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-899931.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8999310.0f) + "'", float2 == (-8999310.0f));
    }

    @Test
    public void test1028() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1028");
        double double1 = org.example.maths.Perimeter.perimeterCircle(599135.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3764476.2290170416d + "'", double1 == 3764476.2290170416d);
    }

    @Test
    public void test1029() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1029");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-105930.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-665577.8195895336d) + "'", double1 == (-665577.8195895336d));
    }

    @Test
    public void test1030() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1030");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(43712.0f, 20283.0f, (-56260.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1031() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1031");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2677470.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6823040164414126E7d + "'", double1 == 1.6823040164414126E7d);
    }

    @Test
    public void test1032() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1032");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-36941.0f), 429361.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 784840.0f + "'", float2 == 784840.0f);
    }

    @Test
    public void test1033() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1033");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(231280.0f, (-71822.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 318916.0f + "'", float2 == 318916.0f);
    }

    @Test
    public void test1034() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1034");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 177152.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-177152.0f) + "'", float2 == (-177152.0f));
    }

    @Test
    public void test1035() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1035");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-1343.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1036() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1036");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5697706.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1395412E7f + "'", float2 == 1.1395412E7f);
    }

    @Test
    public void test1037() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1037");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(189999.0f, 812.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 381622.0f + "'", float2 == 381622.0f);
    }

    @Test
    public void test1038() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1038");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9120327.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.730470460307328E7d + "'", double1 == 5.730470460307328E7d);
    }

    @Test
    public void test1039() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1039");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 269824.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8634368.0f + "'", float2 == 8634368.0f);
    }

    @Test
    public void test1040() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1040");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 2.304E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.19808E9f + "'", float2 == 1.19808E9f);
    }

    @Test
    public void test1041() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1041");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 83494.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 834940.0f + "'", float2 == 834940.0f);
    }

    @Test
    public void test1042() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1042");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9310.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 58496.455209841944d + "'", double1 == 58496.455209841944d);
    }

    @Test
    public void test1043() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1043");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1560770.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9806607.131886683d + "'", double1 == 9806607.131886683d);
    }

    @Test
    public void test1044() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1044");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42798.0f, 1664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 88924.0f + "'", float2 == 88924.0f);
    }

    @Test
    public void test1045() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1045");
        double double1 = org.example.maths.Perimeter.perimeterCircle(232985.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1463887.928793236d + "'", double1 == 1463887.928793236d);
    }

    @Test
    public void test1046() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1046");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4.30678E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.70602968172549E8d) + "'", double1 == (-2.70602968172549E8d));
    }

    @Test
    public void test1047() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1047");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2371643.0f, 7947170.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.0637626E7f + "'", float2 == 2.0637626E7f);
    }

    @Test
    public void test1048() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1048");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-4.353296E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.39305472E9f) + "'", float2 == (-1.39305472E9f));
    }

    @Test
    public void test1049() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1049");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 3.10038E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.0073687E9f + "'", float2 == 3.0073687E9f);
    }

    @Test
    public void test1050() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1050");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5867026.0f, 19468.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1772988E7f + "'", float2 == 1.1772988E7f);
    }

    @Test
    public void test1051() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1051");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 88976.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 88976.0f + "'", float2 == 88976.0f);
    }

    @Test
    public void test1052() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1052");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(17000.0f, 888126.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1810252.0f + "'", float2 == 1810252.0f);
    }

    @Test
    public void test1053() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1053");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 175744.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-175744.0f) + "'", float2 == (-175744.0f));
    }

    @Test
    public void test1054() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1054");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 852.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8520.0f + "'", float2 == 8520.0f);
    }

    @Test
    public void test1055() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1055");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-93500.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-93500.0f) + "'", float2 == (-93500.0f));
    }

    @Test
    public void test1056() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1056");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-385150.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2419968.8210602175d) + "'", double1 == (-2419968.8210602175d));
    }

    @Test
    public void test1057() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1057");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3289483.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.0668431253817026E7d + "'", double1 == 2.0668431253817026E7d);
    }

    @Test
    public void test1058() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1058");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 1425600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1059() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1059");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(890014.0f, (-58.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1779912.0f + "'", float2 == 1779912.0f);
    }

    @Test
    public void test1060() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1060");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 14305.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 500675.0f + "'", float2 == 500675.0f);
    }

    @Test
    public void test1061() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1061");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(410709.0f, 2780.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 826978.0f + "'", float2 == 826978.0f);
    }

    @Test
    public void test1062() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1062");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2439627.0f, 21470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4922194.0f + "'", float2 == 4922194.0f);
    }

    @Test
    public void test1063() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1063");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7935393.0f, 6068720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.8008226E7f + "'", float2 == 2.8008226E7f);
    }

    @Test
    public void test1064() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1064");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5480.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 34431.85548334413d + "'", double1 == 34431.85548334413d);
    }

    @Test
    public void test1065() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1065");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9144.0f, 178809.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 375906.0f + "'", float2 == 375906.0f);
    }

    @Test
    public void test1066() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1066");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7891415.0f, 8848152.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.3479134E7f + "'", float2 == 3.3479134E7f);
    }

    @Test
    public void test1067() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1067");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.1462696E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.2334965537504965E8d + "'", double1 == 3.2334965537504965E8d);
    }

    @Test
    public void test1068() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1068");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) '4', 1.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 106.0f + "'", float2 == 106.0f);
    }

    @Test
    public void test1069() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1069");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 510.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1070() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1070");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(486110.0f, 34.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 972288.0f + "'", float2 == 972288.0f);
    }

    @Test
    public void test1071() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1071");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2275192.0f, 2.91968E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.2943984E7f + "'", float2 == 6.2943984E7f);
    }

    @Test
    public void test1072() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1072");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 285176.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2851760.0f + "'", float2 == 2851760.0f);
    }

    @Test
    public void test1073() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1073");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2331240.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.464761291550934E7d + "'", double1 == 1.464761291550934E7d);
    }

    @Test
    public void test1074() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1074");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5742080.0f, 297144.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2078448E7f + "'", float2 == 1.2078448E7f);
    }

    @Test
    public void test1075() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1075");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.150826E8f), (-0.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.301652E8f) + "'", float2 == (-2.301652E8f));
    }

    @Test
    public void test1076() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1076");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(124936.0f, 37191.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 324254.0f + "'", float2 == 324254.0f);
    }

    @Test
    public void test1077() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1077");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 20198.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20198.0f + "'", float2 == 20198.0f);
    }

    @Test
    public void test1078() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1078");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-88.0f), 231280.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 462384.0f + "'", float2 == 462384.0f);
    }

    @Test
    public void test1079() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1079");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 8599725.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.5997248E7f + "'", float2 == 8.5997248E7f);
    }

    @Test
    public void test1080() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1080");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19820.0f), 7935393.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.5831146E7f + "'", float2 == 1.5831146E7f);
    }

    @Test
    public void test1081() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1081");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.279548E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.039637193431026E8d + "'", double1 == 8.039637193431026E8d);
    }

    @Test
    public void test1082() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1082");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.12044864E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.2172727661015697E9d + "'", double1 == 3.2172727661015697E9d);
    }

    @Test
    public void test1083() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1083");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.00422336E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.2592906767858102E9d + "'", double1 == 1.2592906767858102E9d);
    }

    @Test
    public void test1084() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1084");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-5387.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1085() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1085");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.50671008E8f), 85664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.01170688E8f) + "'", float2 == (-3.01170688E8f));
    }

    @Test
    public void test1086() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1086");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2371643.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.4901472451475315E7d + "'", double1 == 1.4901472451475315E7d);
    }

    @Test
    public void test1087() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1087");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1088() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1088");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 39515.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-39515.0f) + "'", float2 == (-39515.0f));
    }

    @Test
    public void test1089() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1089");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-481312.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3024172.486569221d) + "'", double1 == (-3024172.486569221d));
    }

    @Test
    public void test1090() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1090");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.4995504E7f), 2020.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.9986968E7f) + "'", float2 == (-8.9986968E7f));
    }

    @Test
    public void test1091() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1091");
        double double1 = org.example.maths.Perimeter.perimeterCircle(17020.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 106939.81392819656d + "'", double1 == 106939.81392819656d);
    }

    @Test
    public void test1092() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1092");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 7772.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7772.0f + "'", float2 == 7772.0f);
    }

    @Test
    public void test1093() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1093");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 441395.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-441395.0f) + "'", float2 == (-441395.0f));
    }

    @Test
    public void test1094() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1094");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.195829E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.391658E7f + "'", float2 == 4.391658E7f);
    }

    @Test
    public void test1095() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1095");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-37192.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-233684.22794462318d) + "'", double1 == (-233684.22794462318d));
    }

    @Test
    public void test1096() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1096");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 3.72976E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.72976E8f + "'", float2 == 3.72976E8f);
    }

    @Test
    public void test1097() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1097");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(889760.0f, 178500.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2136520.0f + "'", float2 == 2136520.0f);
    }

    @Test
    public void test1098() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1098");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.27959576E8f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.55919152E8f + "'", float2 == 2.55919152E8f);
    }

    @Test
    public void test1099() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1099");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (byte) 10, 3040640.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6081300.0f + "'", float2 == 6081300.0f);
    }

    @Test
    public void test1100() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1100");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.8622046E7f, 5290.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.7254672E7f + "'", float2 == 3.7254672E7f);
    }

    @Test
    public void test1101() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1101");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1073460.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6744748.099844999d + "'", double1 == 6744748.099844999d);
    }

    @Test
    public void test1102() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1102");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 2283949.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1103() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1103");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5226.0f, 1939800.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3890052.0f + "'", float2 == 3890052.0f);
    }

    @Test
    public void test1104() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1104");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 795642.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.5460544E7f + "'", float2 == 2.5460544E7f);
    }

    @Test
    public void test1105() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1105");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-164.0f), 439021.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 877714.0f + "'", float2 == 877714.0f);
    }

    @Test
    public void test1106() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1106");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 2235184.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2235184.0f) + "'", float2 == (-2235184.0f));
    }

    @Test
    public void test1107() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1107");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-42746.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-268581.0391406986d) + "'", double1 == (-268581.0391406986d));
    }

    @Test
    public void test1108() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1108");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-52.0f), 20198.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 40292.0f + "'", float2 == 40292.0f);
    }

    @Test
    public void test1109() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1109");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-5.970514E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.7913984E9f) + "'", float2 == (-5.7913984E9f));
    }

    @Test
    public void test1110() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1110");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1340698.0f, (-1.563036E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.8579324E7f) + "'", float2 == (-2.8579324E7f));
    }

    @Test
    public void test1111() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1111");
        double double1 = org.example.maths.Perimeter.perimeterCircle(441395.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2773366.5786625333d + "'", double1 == 2773366.5786625333d);
    }

    @Test
    public void test1112() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1112");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 444826.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1113() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1113");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.2186086E8f), 3.7254672E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.56921242E9f) + "'", float2 == (-1.56921242E9f));
    }

    @Test
    public void test1114() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1114");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4425034.0f), 42889.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8764290.0f) + "'", float2 == (-8764290.0f));
    }

    @Test
    public void test1115() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1115");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(607708.0f, (-1.19720472E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.38225536E8f) + "'", float2 == (-2.38225536E8f));
    }

    @Test
    public void test1116() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1116");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1624623.0f), 2147000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1044754.0f + "'", float2 == 1044754.0f);
    }

    @Test
    public void test1117() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1117");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-6312.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1118() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1118");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(929165.0f, 1480.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1861290.0f + "'", float2 == 1861290.0f);
    }

    @Test
    public void test1119() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1119");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.27959576E8f), 39279.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.55840592E8f) + "'", float2 == (-2.55840592E8f));
    }

    @Test
    public void test1120() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1120");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(180432.0f, (-26820.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 307224.0f + "'", float2 == 307224.0f);
    }

    @Test
    public void test1121() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1121");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-38515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-385150.0f) + "'", float2 == (-385150.0f));
    }

    @Test
    public void test1122() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1122");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 57991.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 57991.0f + "'", float2 == 57991.0f);
    }

    @Test
    public void test1123() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1123");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1217.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 12170.0f + "'", float2 == 12170.0f);
    }

    @Test
    public void test1124() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1124");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(9981160.0f, 887332.0f, 3768.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1125() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1125");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(526660.0f, (-3953000.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6852680.0f) + "'", float2 == (-6852680.0f));
    }

    @Test
    public void test1126() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1126");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(42792.0f, 0.0f, 85740.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1127() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1127");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8120.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 51019.46469429824d + "'", double1 == 51019.46469429824d);
    }

    @Test
    public void test1128() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1128");
        double double1 = org.example.maths.Perimeter.perimeterCircle(81004.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 508963.1426227752d + "'", double1 == 508963.1426227752d);
    }

    @Test
    public void test1129() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1129");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 2206.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2206.0f + "'", float2 == 2206.0f);
    }

    @Test
    public void test1130() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1130");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2263.0f, 66317.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 137160.0f + "'", float2 == 137160.0f);
    }

    @Test
    public void test1131() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1131");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(877714.0f, 579910.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2915248.0f + "'", float2 == 2915248.0f);
    }

    @Test
    public void test1132() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1132");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(801055.0f, 4.98962E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.01394512E8f + "'", float2 == 1.01394512E8f);
    }

    @Test
    public void test1133() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1133");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2028300.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.2744184758552354E7d + "'", double1 == 1.2744184758552354E7d);
    }

    @Test
    public void test1134() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1134");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 2.9327112E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.93271104E8f + "'", float2 == 2.93271104E8f);
    }

    @Test
    public void test1135() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1135");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-399330.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.9933E7f) + "'", float2 == (-3.9933E7f));
    }

    @Test
    public void test1136() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1136");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) -1, 42798.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 85594.0f + "'", float2 == 85594.0f);
    }

    @Test
    public void test1137() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1137");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3693052.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.3204130065050185E7d + "'", double1 == 2.3204130065050185E7d);
    }

    @Test
    public void test1138() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1138");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 52.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 52.0f + "'", float2 == 52.0f);
    }

    @Test
    public void test1139() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1139");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-481312.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1140() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1140");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 10, 1939800.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3879620.0f + "'", float2 == 3879620.0f);
    }

    @Test
    public void test1141() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1141");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.45560576E8f, 1425316.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.93971776E8f + "'", float2 == 2.93971776E8f);
    }

    @Test
    public void test1142() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1142");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-68.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 68.0f + "'", float2 == 68.0f);
    }

    @Test
    public void test1143() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1143");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 3547016.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2414556E8f + "'", float2 == 1.2414556E8f);
    }

    @Test
    public void test1144() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1144");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 135000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-135000.0f) + "'", float2 == (-135000.0f));
    }

    @Test
    public void test1145() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1145");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7.4518976E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.682165351092682E8d + "'", double1 == 4.682165351092682E8d);
    }

    @Test
    public void test1146() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1146");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-78922.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-495881.5508132273d) + "'", double1 == (-495881.5508132273d));
    }

    @Test
    public void test1147() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1147");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 8422.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 842200.0f + "'", float2 == 842200.0f);
    }

    @Test
    public void test1148() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1148");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 200792.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 200792.0f + "'", float2 == 200792.0f);
    }

    @Test
    public void test1149() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1149");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.5993138E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0048784969729552E8d + "'", double1 == 1.0048784969729552E8d);
    }

    @Test
    public void test1150() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1150");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-39416.0f), 804707.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1530582.0f + "'", float2 == 1530582.0f);
    }

    @Test
    public void test1151() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1151");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-48760.0f), 2.8008226E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.5918932E7f + "'", float2 == 5.5918932E7f);
    }

    @Test
    public void test1152() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1152");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-970.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6094.689747964198d) + "'", double1 == (-6094.689747964198d));
    }

    @Test
    public void test1153() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1153");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4656492.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.9257602117399286E7d + "'", double1 == 2.9257602117399286E7d);
    }

    @Test
    public void test1154() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1154");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 80242.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7783474.0f + "'", float2 == 7783474.0f);
    }

    @Test
    public void test1155() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1155");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(1.2691684E7f, 2915248.0f, 269824.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1156() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1156");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(155107.0f, 2623704.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5557622.0f + "'", float2 == 5557622.0f);
    }

    @Test
    public void test1157() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1157");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-66.0f), (-42746.0f), 901.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1158() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1158");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 2880875.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1159() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1159");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-0.0f), (-472.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-944.0f) + "'", float2 == (-944.0f));
    }

    @Test
    public void test1160() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1160");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 1375069.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.4002208E7f + "'", float2 == 4.4002208E7f);
    }

    @Test
    public void test1161() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1161");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-3872167.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1162() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1162");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3776522.0f, 429320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8411684.0f + "'", float2 == 8411684.0f);
    }

    @Test
    public void test1163() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1163");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-11252.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-22504.0f) + "'", float2 == (-22504.0f));
    }

    @Test
    public void test1164() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1164");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1165() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1165");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(607708.0f, 1375069.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3965554.0f + "'", float2 == 3965554.0f);
    }

    @Test
    public void test1166() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1166");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(195344.0f, (-31975.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 326738.0f + "'", float2 == 326738.0f);
    }

    @Test
    public void test1167() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1167");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (float) 1L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1168() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1168");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-749040.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4706357.122489797d) + "'", double1 == (-4706357.122489797d));
    }

    @Test
    public void test1169() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1169");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 166025.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-166025.0f) + "'", float2 == (-166025.0f));
    }

    @Test
    public void test1170() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1170");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1800582.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1313390366772033E7d + "'", double1 == 1.1313390366772033E7d);
    }

    @Test
    public void test1171() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1171");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-75434.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-75434.0f) + "'", float2 == (-75434.0f));
    }

    @Test
    public void test1172() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1172");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 9120327.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.74256992E8f + "'", float2 == 4.74256992E8f);
    }

    @Test
    public void test1173() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1173");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.55919152E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6079874556722593E9d + "'", double1 == 1.6079874556722593E9d);
    }

    @Test
    public void test1174() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1174");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(718.0f, 4228.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9892.0f + "'", float2 == 9892.0f);
    }

    @Test
    public void test1175() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1175");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-9.8820312E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.8820314E8f) + "'", float2 == (-9.8820314E8f));
    }

    @Test
    public void test1176() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1176");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 4724.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4724.0f + "'", float2 == 4724.0f);
    }

    @Test
    public void test1177() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1177");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4672052.0f, 158.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9344420.0f + "'", float2 == 9344420.0f);
    }

    @Test
    public void test1178() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1178");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.9933E7f), (-5626.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.9877248E7f) + "'", float2 == (-7.9877248E7f));
    }

    @Test
    public void test1179() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1179");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 305565.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 305565.0f + "'", float2 == 305565.0f);
    }

    @Test
    public void test1180() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1180");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 4920644.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4920644.0f) + "'", float2 == (-4920644.0f));
    }

    @Test
    public void test1181() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1181");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1340698.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1182() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1182");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 1.45560576E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.6579384E9f + "'", float2 == 4.6579384E9f);
    }

    @Test
    public void test1183() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1183");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-9920.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-317440.0f) + "'", float2 == (-317440.0f));
    }

    @Test
    public void test1184() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1184");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 505770.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 505770.0f + "'", float2 == 505770.0f);
    }

    @Test
    public void test1185() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1185");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1317750.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8279667.4385359d + "'", double1 == 8279667.4385359d);
    }

    @Test
    public void test1186() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1186");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(107162.0f, 4.74256992E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.4872832E8f + "'", float2 == 9.4872832E8f);
    }

    @Test
    public void test1187() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1187");
        double double1 = org.example.maths.Perimeter.perimeterCircle(468.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2940.5307237600464d + "'", double1 == 2940.5307237600464d);
    }

    @Test
    public void test1188() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1188");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(798.0f, (-7816300.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.5631004E7f) + "'", float2 == (-1.5631004E7f));
    }

    @Test
    public void test1189() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1189");
        double double1 = org.example.maths.Perimeter.perimeterCircle(21508.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 135138.74958681854d + "'", double1 == 135138.74958681854d);
    }

    @Test
    public void test1190() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1190");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 42980.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42980.0f + "'", float2 == 42980.0f);
    }

    @Test
    public void test1191() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1191");
        double double1 = org.example.maths.Perimeter.perimeterCircle(83494.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 524608.2740376524d + "'", double1 == 524608.2740376524d);
    }

    @Test
    public void test1192() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1192");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 4.9896E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.9896E7f + "'", float2 == 4.9896E7f);
    }

    @Test
    public void test1193() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1193");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1200080.0f, (-1.56921242E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.13602458E9f) + "'", float2 == (-3.13602458E9f));
    }

    @Test
    public void test1194() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1194");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 1861290.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.678708E7f + "'", float2 == 9.678708E7f);
    }

    @Test
    public void test1195() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1195");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(88976.0f, 1.44599088E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.89376128E8f + "'", float2 == 2.89376128E8f);
    }

    @Test
    public void test1196() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1196");
        double double1 = org.example.maths.Perimeter.perimeterCircle(390812.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2455544.2162694684d + "'", double1 == 2455544.2162694684d);
    }

    @Test
    public void test1197() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1197");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 229341.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-229341.0f) + "'", float2 == (-229341.0f));
    }

    @Test
    public void test1198() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1198");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.93271104E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8426766916731365E9d + "'", double1 == 1.8426766916731365E9d);
    }

    @Test
    public void test1199() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1199");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 20280.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20280.0f + "'", float2 == 20280.0f);
    }

    @Test
    public void test1200() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1200");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-826550.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1201() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1201");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 524175.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.72571E7f + "'", float2 == 2.72571E7f);
    }

    @Test
    public void test1202() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1202");
        double double1 = org.example.maths.Perimeter.perimeterCircle(31548.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 198221.93007090158d + "'", double1 == 198221.93007090158d);
    }

    @Test
    public void test1203() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1203");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-48760.0f), 694284.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1291048.0f + "'", float2 == 1291048.0f);
    }

    @Test
    public void test1204() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1204");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4462487.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.8038632751879912E7d + "'", double1 == 2.8038632751879912E7d);
    }

    @Test
    public void test1205() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1205");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1206() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1206");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-66.0f), 444832.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 889532.0f + "'", float2 == 889532.0f);
    }

    @Test
    public void test1207() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1207");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 291880.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.9188E7f + "'", float2 == 2.9188E7f);
    }

    @Test
    public void test1208() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1208");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2623704.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6485218423188308E7d + "'", double1 == 1.6485218423188308E7d);
    }

    @Test
    public void test1209() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1209");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-150.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-942.4777960769379d) + "'", double1 == (-942.4777960769379d));
    }

    @Test
    public void test1210() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1210");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.9327112E7f, 3663.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.8661552E7f + "'", float2 == 5.8661552E7f);
    }

    @Test
    public void test1211() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1211");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-944.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1888.0f) + "'", float2 == (-1888.0f));
    }

    @Test
    public void test1212() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1212");
        double double1 = org.example.maths.Perimeter.perimeterCircle(417693.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2624442.5205117627d + "'", double1 == 2624442.5205117627d);
    }

    @Test
    public void test1213() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1213");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4574925.0f, (-74.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9149702.0f + "'", float2 == 9149702.0f);
    }

    @Test
    public void test1214() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1214");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3087539.0f, 5.4581256E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.15337592E8f + "'", float2 == 1.15337592E8f);
    }

    @Test
    public void test1215() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1215");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2304000.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.4476458947741767E7d + "'", double1 == 1.4476458947741767E7d);
    }

    @Test
    public void test1216() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1216");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.15337592E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.246874634198738E8d + "'", double1 == 7.246874634198738E8d);
    }

    @Test
    public void test1217() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1217");
        double double1 = org.example.maths.Perimeter.perimeterCircle(305565.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1919921.5183883302d + "'", double1 == 1919921.5183883302d);
    }

    @Test
    public void test1218() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1218");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-1.74001664E8f), 14722.0f, 1.189078E7f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1219() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1219");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 76567.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-76567.0f) + "'", float2 == (-76567.0f));
    }

    @Test
    public void test1220() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1220");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4493662.0f, (-8.2188646E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.63478566E9f) + "'", float2 == (-1.63478566E9f));
    }

    @Test
    public void test1221() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1221");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.0035256E8f, 316.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.0070576E8f + "'", float2 == 2.0070576E8f);
    }

    @Test
    public void test1222() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1222");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1426376.0f, 53.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2852858.0f + "'", float2 == 2852858.0f);
    }

    @Test
    public void test1223() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1223");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-39731.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-249637.23543955214d) + "'", double1 == (-249637.23543955214d));
    }

    @Test
    public void test1224() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1224");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(88576.0f, 407543.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 992238.0f + "'", float2 == 992238.0f);
    }

    @Test
    public void test1225() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1225");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1226() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1226");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-92668.0f), (-99506.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-384348.0f) + "'", float2 == (-384348.0f));
    }

    @Test
    public void test1227() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1227");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 9149702.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.1497024E7f + "'", float2 == 9.1497024E7f);
    }

    @Test
    public void test1228() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1228");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 37483.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3635851.0f + "'", float2 == 3635851.0f);
    }

    @Test
    public void test1229() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1229");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-39731.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3853907.0f) + "'", float2 == (-3853907.0f));
    }

    @Test
    public void test1230() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1230");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-888126.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5580260.234124177d) + "'", double1 == (-5580260.234124177d));
    }

    @Test
    public void test1231() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1231");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 890014.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-890014.0f) + "'", float2 == (-890014.0f));
    }

    @Test
    public void test1232() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1232");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(117.0f, 5.11965376E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.02393101E9f + "'", float2 == 1.02393101E9f);
    }

    @Test
    public void test1233() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1233");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 2.72571E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.72571008E8f + "'", float2 == 2.72571008E8f);
    }

    @Test
    public void test1234() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1234");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-1.150826E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.6826432E9f) + "'", float2 == (-3.6826432E9f));
    }

    @Test
    public void test1235() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1235");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-37192.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1933984.0f) + "'", float2 == (-1933984.0f));
    }

    @Test
    public void test1236() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1236");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.279548E8f, 9981160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.75871936E8f + "'", float2 == 2.75871936E8f);
    }

    @Test
    public void test1237() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1237");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 156.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1560.0f + "'", float2 == 1560.0f);
    }

    @Test
    public void test1238() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1238");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-198.0f), 269248.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 538100.0f + "'", float2 == 538100.0f);
    }

    @Test
    public void test1239() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1239");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-193.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1240() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1240");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-890014.0f), 520.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1778988.0f) + "'", float2 == (-1778988.0f));
    }

    @Test
    public void test1241() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1241");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(1425140.0f, 266670.0f, 439021.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1242() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1242");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5480.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-34431.85548334413d) + "'", double1 == (-34431.85548334413d));
    }

    @Test
    public void test1243() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1243");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1425316.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1244() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1244");
        double double1 = org.example.maths.Perimeter.perimeterCircle((float) 0);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 0.0d + "'", double1 == 0.0d);
    }

    @Test
    public void test1245() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1245");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9352.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 58760.34899274349d + "'", double1 == 58760.34899274349d);
    }

    @Test
    public void test1246() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1246");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 2394591.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.394591E7f + "'", float2 == 2.394591E7f);
    }

    @Test
    public void test1247() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1247");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1248() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1248");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(590839.0f, 2180928.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5543534.0f + "'", float2 == 5543534.0f);
    }

    @Test
    public void test1249() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1249");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-3.0078922E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.0078922E7f) + "'", float2 == (-3.0078922E7f));
    }

    @Test
    public void test1250() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1250");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-39602.0f), (-3.6826432E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.3653658E9f) + "'", float2 == (-7.3653658E9f));
    }

    @Test
    public void test1251() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1251");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.2949888E7f), 135.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.5899504E7f) + "'", float2 == (-8.5899504E7f));
    }

    @Test
    public void test1252() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1252");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4734.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 29744.59924418816d + "'", double1 == 29744.59924418816d);
    }

    @Test
    public void test1253() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1253");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4.6579384E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.926669031768952E10d + "'", double1 == 2.926669031768952E10d);
    }

    @Test
    public void test1254() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1254");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-97.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-194.0f) + "'", float2 == (-194.0f));
    }

    @Test
    public void test1255() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1255");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4738.0f, 1.28386E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.5686676E7f + "'", float2 == 2.5686676E7f);
    }

    @Test
    public void test1256() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1256");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(629860.0f, (-229267.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 801186.0f + "'", float2 == 801186.0f);
    }

    @Test
    public void test1257() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1257");
        double double1 = org.example.maths.Perimeter.perimeterCircle(81200.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 510194.6469429824d + "'", double1 == 510194.6469429824d);
    }

    @Test
    public void test1258() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1258");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-2028300.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.0283E7f) + "'", float2 == (-2.0283E7f));
    }

    @Test
    public void test1259() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1259");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 939319.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 939319.0f + "'", float2 == 939319.0f);
    }

    @Test
    public void test1260() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1260");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1397915.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1397915.0f + "'", float2 == 1397915.0f);
    }

    @Test
    public void test1261() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1261");
        double double1 = org.example.maths.Perimeter.perimeterCircle(178809.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1123490.0815914746d + "'", double1 == 1123490.0815914746d);
    }

    @Test
    public void test1262() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1262");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-42.0f), 307224.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 614364.0f + "'", float2 == 614364.0f);
    }

    @Test
    public void test1263() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1263");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 5.12044864E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1204485E9f + "'", float2 == 5.1204485E9f);
    }

    @Test
    public void test1264() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1264");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 41496.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 414960.0f + "'", float2 == 414960.0f);
    }

    @Test
    public void test1265() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1265");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-22504.0f), 606872.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1168736.0f + "'", float2 == 1168736.0f);
    }

    @Test
    public void test1266() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1266");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(9.4872832E8f, 178500.0f, 0.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1267() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1267");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 1263140.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1268() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1268");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7913000.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.5826E7f + "'", float2 == 1.5826E7f);
    }

    @Test
    public void test1269() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1269");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5557622.0f, 1375069.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.3865382E7f + "'", float2 == 1.3865382E7f);
    }

    @Test
    public void test1270() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1270");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 1.373824E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.3962368E8f + "'", float2 == 4.3962368E8f);
    }

    @Test
    public void test1271() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1271");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86064.0f, 6162800.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2497728E7f + "'", float2 == 1.2497728E7f);
    }

    @Test
    public void test1272() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1272");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 2202.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1273() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1273");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-19805.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-124438.4850086917d) + "'", double1 == (-124438.4850086917d));
    }

    @Test
    public void test1274() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1274");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-4056330.0f), 8430.0f, 556283.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1275() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1275");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2056880.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.2923758194631547E7d) + "'", double1 == (-1.2923758194631547E7d));
    }

    @Test
    public void test1276() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1276");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-2.860396E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.860396E7f) + "'", float2 == (-2.860396E7f));
    }

    @Test
    public void test1277() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1277");
        double double1 = org.example.maths.Perimeter.perimeterCircle(478404.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3005900.983695943d + "'", double1 == 3005900.983695943d);
    }

    @Test
    public void test1278() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1278");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3348.0f, 1668285.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3343266.0f + "'", float2 == 3343266.0f);
    }

    @Test
    public void test1279() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1279");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(116018.0f, 5.4581256E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.09394544E8f + "'", float2 == 1.09394544E8f);
    }

    @Test
    public void test1280() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1280");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1191277.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7485014.143180976d + "'", double1 == 7485014.143180976d);
    }

    @Test
    public void test1281() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1281");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 85664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2998240.0f + "'", float2 == 2998240.0f);
    }

    @Test
    public void test1282() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1282");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.8579324E7f), 15712.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.7127224E7f) + "'", float2 == (-5.7127224E7f));
    }

    @Test
    public void test1283() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1283");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2328718.0f, (-14812.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4627812.0f + "'", float2 == 4627812.0f);
    }

    @Test
    public void test1284() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1284");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.8650242E7f, 2.9188E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.567648E7f + "'", float2 == 9.567648E7f);
    }

    @Test
    public void test1285() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1285");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.12849536E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.222328669389068E9d + "'", double1 == 3.222328669389068E9d);
    }

    @Test
    public void test1286() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1286");
        double double1 = org.example.maths.Perimeter.perimeterCircle(195344.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1227382.550645689d + "'", double1 == 1227382.550645689d);
    }

    @Test
    public void test1287() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1287");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 483300.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.68801E7f + "'", float2 == 4.68801E7f);
    }

    @Test
    public void test1288() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1288");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2292670.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4405270458211422E7d) + "'", double1 == (-1.4405270458211422E7d));
    }

    @Test
    public void test1289() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1289");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9137503.0f, 1.7501904E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.3278816E7f + "'", float2 == 5.3278816E7f);
    }

    @Test
    public void test1290() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1290");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 324.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1291() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1291");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.05183632E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.608882511381845E8d + "'", double1 == 6.608882511381845E8d);
    }

    @Test
    public void test1292() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1292");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.1197558E7f), (-5443242.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.32816E7f) + "'", float2 == (-7.32816E7f));
    }

    @Test
    public void test1293() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1293");
        double double1 = org.example.maths.Perimeter.perimeterCircle(39515.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 248280.06741320135d + "'", double1 == 248280.06741320135d);
    }

    @Test
    public void test1294() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1294");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 85492.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1295() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1295");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 1.59694E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.59694E7f + "'", float2 == 1.59694E7f);
    }

    @Test
    public void test1296() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1296");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7617075.0f, 42097.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.5318344E7f + "'", float2 == 1.5318344E7f);
    }

    @Test
    public void test1297() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1297");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-944.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5931.326929977529d) + "'", double1 == (-5931.326929977529d));
    }

    @Test
    public void test1298() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1298");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.27959576E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.039937278361297E8d + "'", double1 == 8.039937278361297E8d);
    }

    @Test
    public void test1299() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1299");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1438000.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9035220.471724246d + "'", double1 == 9035220.471724246d);
    }

    @Test
    public void test1300() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1300");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6800.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 42725.66008882118d + "'", double1 == 42725.66008882118d);
    }

    @Test
    public void test1301() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1301");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 2371643.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1302() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1302");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 85664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1303() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1303");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.38225536E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4968151875901816E9d) + "'", double1 == (-1.4968151875901816E9d));
    }

    @Test
    public void test1304() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1304");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-17284.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-604940.0f) + "'", float2 == (-604940.0f));
    }

    @Test
    public void test1305() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1305");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 161116.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5155712.0f + "'", float2 == 5155712.0f);
    }

    @Test
    public void test1306() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1306");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3879620.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.4376371381440066E7d + "'", double1 == 2.4376371381440066E7d);
    }

    @Test
    public void test1307() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1307");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-1.5631004E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.1281222E8f) + "'", float2 == (-8.1281222E8f));
    }

    @Test
    public void test1308() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1308");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(414960.0f, 42889.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 915698.0f + "'", float2 == 915698.0f);
    }

    @Test
    public void test1309() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1309");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 42097.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42097.0f + "'", float2 == 42097.0f);
    }

    @Test
    public void test1310() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1310");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41746.0f, 234018.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 551528.0f + "'", float2 == 551528.0f);
    }

    @Test
    public void test1311() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1311");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(400258.0f, 357818.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1516152.0f + "'", float2 == 1516152.0f);
    }

    @Test
    public void test1312() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1312");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5359.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 33671.590061175404d + "'", double1 == 33671.590061175404d);
    }

    @Test
    public void test1313() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1313");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 21856.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 43712.0f + "'", float2 == 43712.0f);
    }

    @Test
    public void test1314() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1314");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 9.567648E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.5676477E9f + "'", float2 == 9.5676477E9f);
    }

    @Test
    public void test1315() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1315");
        double double1 = org.example.maths.Perimeter.perimeterCircle(67283.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 422751.5570229641d + "'", double1 == 422751.5570229641d);
    }

    @Test
    public void test1316() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1316");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4738.0f, 780616.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1570708.0f + "'", float2 == 1570708.0f);
    }

    @Test
    public void test1317() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1317");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.44599088E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.08542865153168E8d + "'", double1 == 9.08542865153168E8d);
    }

    @Test
    public void test1318() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1318");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.7444768E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.0960870998475661E9d) + "'", double1 == (-1.0960870998475661E9d));
    }

    @Test
    public void test1319() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1319");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 4.6579384E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.6579384E9f) + "'", float2 == (-4.6579384E9f));
    }

    @Test
    public void test1320() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1320");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(530.0f, (-34534.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-68008.0f) + "'", float2 == (-68008.0f));
    }

    @Test
    public void test1321() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1321");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 7.16004E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.16004E7f) + "'", float2 == (-7.16004E7f));
    }

    @Test
    public void test1322() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1322");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1033946.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2067892.0f + "'", float2 == 2067892.0f);
    }

    @Test
    public void test1323() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1323");
        double double1 = org.example.maths.Perimeter.perimeterCircle(137160.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 861801.696732752d + "'", double1 == 861801.696732752d);
    }

    @Test
    public void test1324() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1324");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2024877.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.272267741524588E7d + "'", double1 == 1.272267741524588E7d);
    }

    @Test
    public void test1325() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1325");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-3.01170688E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.01170688E8f + "'", float2 == 3.01170688E8f);
    }

    @Test
    public void test1326() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1326");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(24356.0f, 109411.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 267534.0f + "'", float2 == 267534.0f);
    }

    @Test
    public void test1327() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1327");
        double double1 = org.example.maths.Perimeter.perimeterCircle(858394.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5393448.568571114d + "'", double1 == 5393448.568571114d);
    }

    @Test
    public void test1328() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1328");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2851760.0f, 7913000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.152952E7f + "'", float2 == 2.152952E7f);
    }

    @Test
    public void test1329() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1329");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.2210262E7f, 444987.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.5310496E7f + "'", float2 == 6.5310496E7f);
    }

    @Test
    public void test1330() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1330");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8848152.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.559457864209167E7d + "'", double1 == 5.559457864209167E7d);
    }

    @Test
    public void test1331() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1331");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-86.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-86.0f) + "'", float2 == (-86.0f));
    }

    @Test
    public void test1332() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1332");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8.1281222E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.107049823332763E9d) + "'", double1 == (-5.107049823332763E9d));
    }

    @Test
    public void test1333() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1333");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3343266.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.1006359809193067E7d + "'", double1 == 2.1006359809193067E7d);
    }

    @Test
    public void test1334() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1334");
        double double1 = org.example.maths.Perimeter.perimeterCircle(297144.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1867010.814916571d + "'", double1 == 1867010.814916571d);
    }

    @Test
    public void test1335() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1335");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1181606.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7424249.458075242d + "'", double1 == 7424249.458075242d);
    }

    @Test
    public void test1336() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1336");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) ' ', (float) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 84.0f + "'", float2 == 84.0f);
    }

    @Test
    public void test1337() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1337");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2479893.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.5581627260977505E7d + "'", double1 == 1.5581627260977505E7d);
    }

    @Test
    public void test1338() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1338");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-4.353296E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1339() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1339");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3348.0f, (-2283558.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4560420.0f) + "'", float2 == (-4560420.0f));
    }

    @Test
    public void test1340() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1340");
        double double1 = org.example.maths.Perimeter.perimeterCircle(80660.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 506801.7268771054d + "'", double1 == 506801.7268771054d);
    }

    @Test
    public void test1341() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1341");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20101.0f, 7185585.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4411372E7f + "'", float2 == 1.4411372E7f);
    }

    @Test
    public void test1342() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1342");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1215672.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7638292.448749622d + "'", double1 == 7638292.448749622d);
    }

    @Test
    public void test1343() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1343");
        double double1 = org.example.maths.Perimeter.perimeterCircle(100255.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 629920.7429712894d + "'", double1 == 629920.7429712894d);
    }

    @Test
    public void test1344() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1344");
        double double1 = org.example.maths.Perimeter.perimeterCircle(107162.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 673318.7038879788d + "'", double1 == 673318.7038879788d);
    }

    @Test
    public void test1345() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1345");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.56167424E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-9.812288639368846E8d) + "'", double1 == (-9.812288639368846E8d));
    }

    @Test
    public void test1346() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1346");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-8764290.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.7642896E7f) + "'", float2 == (-8.7642896E7f));
    }

    @Test
    public void test1347() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1347");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 4.6579384E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.65793843E11f + "'", float2 == 4.65793843E11f);
    }

    @Test
    public void test1348() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1348");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8566100.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.3822393659831055E7d + "'", double1 == 5.3822393659831055E7d);
    }

    @Test
    public void test1349() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1349");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 2.02896064E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.492674E10f + "'", float2 == 6.492674E10f);
    }

    @Test
    public void test1350() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1350");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 178809.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1788090.0f + "'", float2 == 1788090.0f);
    }

    @Test
    public void test1351() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1351");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7.4518976E7f, (-88.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.49037776E8f + "'", float2 == 1.49037776E8f);
    }

    @Test
    public void test1352() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1352");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(489806.0f, (-3.0521238E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.0062864E7f) + "'", float2 == (-6.0062864E7f));
    }

    @Test
    public void test1353() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1353");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-42746.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4274600.0f) + "'", float2 == (-4274600.0f));
    }

    @Test
    public void test1354() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1354");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-229341.0f), (-5.7127224E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.14713128E8f) + "'", float2 == (-1.14713128E8f));
    }

    @Test
    public void test1355() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1355");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-58840.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-369702.6234744469d) + "'", double1 == (-369702.6234744469d));
    }

    @Test
    public void test1356() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1356");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.6964508E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0659114740913054E8d + "'", double1 == 1.0659114740913054E8d);
    }

    @Test
    public void test1357() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1357");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6800.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 13600.0f + "'", float2 == 13600.0f);
    }

    @Test
    public void test1358() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1358");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-4.6579384E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.63027845E11f) + "'", float2 == (-1.63027845E11f));
    }

    @Test
    public void test1359() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1359");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(229341.0f, 3.01170688E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.0280006E8f + "'", float2 == 6.0280006E8f);
    }

    @Test
    public void test1360() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1360");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 310038.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.10038E7f + "'", float2 == 3.10038E7f);
    }

    @Test
    public void test1361() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1361");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(156.0f, 2.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 316.0f + "'", float2 == 316.0f);
    }

    @Test
    public void test1362() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1362");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 10, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 20.0f + "'", float2 == 20.0f);
    }

    @Test
    public void test1363() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1363");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-85740.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-538720.3082375777d) + "'", double1 == (-538720.3082375777d));
    }

    @Test
    public void test1364() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1364");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(83494.0f, 77268.0f, (-5.7127224E7f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1365() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1365");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9144.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 57453.44644885014d + "'", double1 == 57453.44644885014d);
    }

    @Test
    public void test1366() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1366");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(985888.0f, (-78922.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1813932.0f + "'", float2 == 1813932.0f);
    }

    @Test
    public void test1367() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1367");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5.970514E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3.751384584111002E8d) + "'", double1 == (-3.751384584111002E8d));
    }

    @Test
    public void test1368() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1368");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(923593.0f, 358002.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2563190.0f + "'", float2 == 2563190.0f);
    }

    @Test
    public void test1369() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1369");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.01170688E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8923112417947674E9d + "'", double1 == 1.8923112417947674E9d);
    }

    @Test
    public void test1370() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1370");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-211374.0f), (-10.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-422768.0f) + "'", float2 == (-422768.0f));
    }

    @Test
    public void test1371() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1371");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 6884.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1372() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1372");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-7.9877248E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.0188355101154E8d) + "'", double1 == (-5.0188355101154E8d));
    }

    @Test
    public void test1373() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1373");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85594.0f, 4922194.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.0015576E7f + "'", float2 == 1.0015576E7f);
    }

    @Test
    public void test1374() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1374");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.47339504E8f), 242989.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.94193024E8f) + "'", float2 == (-2.94193024E8f));
    }

    @Test
    public void test1375() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1375");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2871398.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.804152572466485E7d + "'", double1 == 1.804152572466485E7d);
    }

    @Test
    public void test1376() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1376");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-9920.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-992000.0f) + "'", float2 == (-992000.0f));
    }

    @Test
    public void test1377() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1377");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8886348.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.58345711880847E7d + "'", double1 == 5.58345711880847E7d);
    }

    @Test
    public void test1378() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1378");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.09394544E8f, 3635851.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.26060784E8f + "'", float2 == 2.26060784E8f);
    }

    @Test
    public void test1379() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1379");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 520.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5200.0f + "'", float2 == 5200.0f);
    }

    @Test
    public void test1380() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1380");
        double double1 = org.example.maths.Perimeter.perimeterCircle(48844.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 306895.9031438797d + "'", double1 == 306895.9031438797d);
    }

    @Test
    public void test1381() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1381");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-4.11109248E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1382() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1382");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 5238.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1383() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1383");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 8430.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 84300.0f + "'", float2 == 84300.0f);
    }

    @Test
    public void test1384() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1384");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(88924.0f, (-4.3048544E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.591924E7f) + "'", float2 == (-8.591924E7f));
    }

    @Test
    public void test1385() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1385");
        double double1 = org.example.maths.Perimeter.perimeterCircle(266168.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1672382.866841376d + "'", double1 == 1672382.866841376d);
    }

    @Test
    public void test1386() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1386");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1156.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1156.0f + "'", float2 == 1156.0f);
    }

    @Test
    public void test1387() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1387");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-28799.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-57598.0f) + "'", float2 == (-57598.0f));
    }

    @Test
    public void test1388() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1388");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-42746.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1496110.0f) + "'", float2 == (-1496110.0f));
    }

    @Test
    public void test1389() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1389");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 1854835.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.854835E7f + "'", float2 == 1.854835E7f);
    }

    @Test
    public void test1390() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1390");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5290.0f, 6284170.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.257892E7f + "'", float2 == 1.257892E7f);
    }

    @Test
    public void test1391() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1391");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 3768.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3768.0f + "'", float2 == 3768.0f);
    }

    @Test
    public void test1392() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1392");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 260.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-260.0f) + "'", float2 == (-260.0f));
    }

    @Test
    public void test1393() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1393");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 889760.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1779520.0f + "'", float2 == 1779520.0f);
    }

    @Test
    public void test1394() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1394");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 137160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.3716E7f + "'", float2 == 1.3716E7f);
    }

    @Test
    public void test1395() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1395");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-194.0f), 1.7501904E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.500342E7f + "'", float2 == 3.500342E7f);
    }

    @Test
    public void test1396() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1396");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 784840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7848400.0f + "'", float2 == 7848400.0f);
    }

    @Test
    public void test1397() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1397");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 2301926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2301926.0f + "'", float2 == 2301926.0f);
    }

    @Test
    public void test1398() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1398");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-2860396.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1399() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1399");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(716004.0f, 956844.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3345696.0f + "'", float2 == 3345696.0f);
    }

    @Test
    public void test1400() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1400");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1.78664016E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1401() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1401");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-26820.0f), 8411684.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.6769728E7f + "'", float2 == 1.6769728E7f);
    }

    @Test
    public void test1402() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1402");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-5443242.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.27994464E8f) + "'", float2 == (-5.27994464E8f));
    }

    @Test
    public void test1403() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1403");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(141644.0f, 1.29495416E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.59274112E8f + "'", float2 == 2.59274112E8f);
    }

    @Test
    public void test1404() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1404");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.59694E7f, (-4091280.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.375624E7f + "'", float2 == 2.375624E7f);
    }

    @Test
    public void test1405() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1405");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 50392.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 503920.0f + "'", float2 == 503920.0f);
    }

    @Test
    public void test1406() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1406");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(73068.0f, (-3.13602458E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.2719032E9f) + "'", float2 == (-6.2719032E9f));
    }

    @Test
    public void test1407() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1407");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-92668.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-185336.0f) + "'", float2 == (-185336.0f));
    }

    @Test
    public void test1408() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1408");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 280885.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1409() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1409");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-884.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 884.0f + "'", float2 == 884.0f);
    }

    @Test
    public void test1410() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1410");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.0753088E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.9322735067200084E9d) + "'", double1 == (-1.9322735067200084E9d));
    }

    @Test
    public void test1411() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1411");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9448.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 59363.53478223273d + "'", double1 == 59363.53478223273d);
    }

    @Test
    public void test1412() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1412");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2283949.0f, (-1.14713128E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.24858352E8f) + "'", float2 == (-2.24858352E8f));
    }

    @Test
    public void test1413() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1413");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3424.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 21513.626491782903d + "'", double1 == 21513.626491782903d);
    }

    @Test
    public void test1414() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1414");
        double double1 = org.example.maths.Perimeter.perimeterCircle(88924.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 558725.9702556375d + "'", double1 == 558725.9702556375d);
    }

    @Test
    public void test1415() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1415");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.2186086E8f), 28.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.64372173E9f) + "'", float2 == (-1.64372173E9f));
    }

    @Test
    public void test1416() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1416");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (float) (short) -1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-35.0f) + "'", float2 == (-35.0f));
    }

    @Test
    public void test1417() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1417");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 19840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1031680.0f + "'", float2 == 1031680.0f);
    }

    @Test
    public void test1418() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1418");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9.4872832E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.961035840729173E9d + "'", double1 == 5.961035840729173E9d);
    }

    @Test
    public void test1419() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1419");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, (-3851500.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3851500.0f) + "'", float2 == (-3851500.0f));
    }

    @Test
    public void test1420() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1420");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.2497728E7f, 177152.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.534976E7f + "'", float2 == 2.534976E7f);
    }

    @Test
    public void test1421() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1421");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 417693.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.17693E7f + "'", float2 == 4.17693E7f);
    }

    @Test
    public void test1422() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1422");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9.567648E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.011530533786615E8d + "'", double1 == 6.011530533786615E8d);
    }

    @Test
    public void test1423() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1423");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(326738.0f, (-2.301652E8f), 0.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1424() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1424");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-899931.0f), 505770.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-788322.0f) + "'", float2 == (-788322.0f));
    }

    @Test
    public void test1425() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1425");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7893746.0f, 4.4041432E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.03870352E8f + "'", float2 == 1.03870352E8f);
    }

    @Test
    public void test1426() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1426");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.14713128E8f), 1032.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.29424192E8f) + "'", float2 == (-2.29424192E8f));
    }

    @Test
    public void test1427() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1427");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21133.0f, 1.189078E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.3823826E7f + "'", float2 == 2.3823826E7f);
    }

    @Test
    public void test1428() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1428");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 8430.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 84300.0f + "'", float2 == 84300.0f);
    }

    @Test
    public void test1429() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1429");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 9144.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 91440.0f + "'", float2 == 91440.0f);
    }

    @Test
    public void test1430() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1430");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 29188.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1021580.0f + "'", float2 == 1021580.0f);
    }

    @Test
    public void test1431() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1431");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 3242.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1432() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1432");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1789972.0f, 42832.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3665608.0f + "'", float2 == 3665608.0f);
    }

    @Test
    public void test1433() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1433");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 200474.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-200474.0f) + "'", float2 == (-200474.0f));
    }

    @Test
    public void test1434() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1434");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8411684.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.285216931743761E7d + "'", double1 == 5.285216931743761E7d);
    }

    @Test
    public void test1435() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1435");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5.1462696E7f, 6.294496E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.28815312E8f + "'", float2 == 2.28815312E8f);
    }

    @Test
    public void test1436() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1436");
        double double1 = org.example.maths.Perimeter.perimeterCircle(812.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5101.946469429824d + "'", double1 == 5101.946469429824d);
    }

    @Test
    public void test1437() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1437");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 812.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 28420.0f + "'", float2 == 28420.0f);
    }

    @Test
    public void test1438() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1438");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3143410.0f, 131775.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6550370.0f + "'", float2 == 6550370.0f);
    }

    @Test
    public void test1439() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1439");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 69.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6900.0f + "'", float2 == 6900.0f);
    }

    @Test
    public void test1440() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1440");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(1433970.0f, (float) (byte) -1, (-196.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1441() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1441");
        double double1 = org.example.maths.Perimeter.perimeterCircle(87220.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 548019.4224922035d + "'", double1 == 548019.4224922035d);
    }

    @Test
    public void test1442() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1442");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(956844.0f, 798.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1915284.0f + "'", float2 == 1915284.0f);
    }

    @Test
    public void test1443() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1443");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1444() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1444");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(48672.0f, 7617075.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.5331494E7f + "'", float2 == 1.5331494E7f);
    }

    @Test
    public void test1445() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1445");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6284170.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.948460461181874E7d + "'", double1 == 3.948460461181874E7d);
    }

    @Test
    public void test1446() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1446");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 13012.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 26024.0f + "'", float2 == 26024.0f);
    }

    @Test
    public void test1447() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1447");
        double double1 = org.example.maths.Perimeter.perimeterCircle(211808.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1330828.9135430937d + "'", double1 == 1330828.9135430937d);
    }

    @Test
    public void test1448() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1448");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-140752.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1407520.0f) + "'", float2 == (-1407520.0f));
    }

    @Test
    public void test1449() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1449");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(297144.0f, (float) 0L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 594288.0f + "'", float2 == 594288.0f);
    }

    @Test
    public void test1450() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1450");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 41835.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2175420.0f + "'", float2 == 2175420.0f);
    }

    @Test
    public void test1451() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1451");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 8422.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 84220.0f + "'", float2 == 84220.0f);
    }

    @Test
    public void test1452() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1452");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.8811578E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.810284835662586E8d + "'", double1 == 1.810284835662586E8d);
    }

    @Test
    public void test1453() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1453");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(84220.0f, (-241500.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-314560.0f) + "'", float2 == (-314560.0f));
    }

    @Test
    public void test1454() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1454");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-229341.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1440992.0015338734d) + "'", double1 == (-1440992.0015338734d));
    }

    @Test
    public void test1455() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1455");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6900.0f, 100255.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 214310.0f + "'", float2 == 214310.0f);
    }

    @Test
    public void test1456() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1456");
        double double1 = org.example.maths.Perimeter.perimeterCircle(250710.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1575257.388362994d + "'", double1 == 1575257.388362994d);
    }

    @Test
    public void test1457() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1457");
        double double1 = org.example.maths.Perimeter.perimeterCircle(266670.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1675537.0258655802d + "'", double1 == 1675537.0258655802d);
    }

    @Test
    public void test1458() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1458");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3926864.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.467321418809246E7d + "'", double1 == 2.467321418809246E7d);
    }

    @Test
    public void test1459() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1459");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(434280.0f, 8094453.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7057466E7f + "'", float2 == 1.7057466E7f);
    }

    @Test
    public void test1460() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1460");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-4940.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4940.0f) + "'", float2 == (-4940.0f));
    }

    @Test
    public void test1461() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1461");
        double double1 = org.example.maths.Perimeter.perimeterCircle(74345.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 467123.41166226636d + "'", double1 == 467123.41166226636d);
    }

    @Test
    public void test1462() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1462");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1988175.0f), (float) (short) 100);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3976150.0f) + "'", float2 == (-3976150.0f));
    }

    @Test
    public void test1463() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1463");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-422768.0f), (-5.970514E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.20255816E8f) + "'", float2 == (-1.20255816E8f));
    }

    @Test
    public void test1464() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1464");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21265.0f, 255726.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 553982.0f + "'", float2 == 553982.0f);
    }

    @Test
    public void test1465() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1465");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(648960.0f, (-1562499.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1827078.0f) + "'", float2 == (-1827078.0f));
    }

    @Test
    public void test1466() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1466");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-19800.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1980000.0f) + "'", float2 == (-1980000.0f));
    }

    @Test
    public void test1467() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1467");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.08518944E8f), 504400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.1602906E8f) + "'", float2 == (-8.1602906E8f));
    }

    @Test
    public void test1468() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1468");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 444826.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 444826.0f + "'", float2 == 444826.0f);
    }

    @Test
    public void test1469() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1469");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.8598484E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.7968957447641048E8d) + "'", double1 == (-1.7968957447641048E8d));
    }

    @Test
    public void test1470() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1470");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5063658.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.1815901546182368E7d + "'", double1 == 3.1815901546182368E7d);
    }

    @Test
    public void test1471() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1471");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(795702.0f, 3.0073687E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.0163287E9f + "'", float2 == 6.0163287E9f);
    }

    @Test
    public void test1472() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1472");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 9.567648E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.567648E8f + "'", float2 == 9.567648E8f);
    }

    @Test
    public void test1473() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1473");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2550141.0f, 62504.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5225290.0f + "'", float2 == 5225290.0f);
    }

    @Test
    public void test1474() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1474");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9.678708E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.081311589808152E8d + "'", double1 == 6.081311589808152E8d);
    }

    @Test
    public void test1475() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1475");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(77318.0f, 1.27964392E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.56083424E8f + "'", float2 == 2.56083424E8f);
    }

    @Test
    public void test1476() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1476");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5359.0f, 8411684.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.6834086E7f + "'", float2 == 1.6834086E7f);
    }

    @Test
    public void test1477() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1477");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2970944.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.866699168925335E7d + "'", double1 == 1.866699168925335E7d);
    }

    @Test
    public void test1478() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1478");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-26.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 26.0f + "'", float2 == 26.0f);
    }

    @Test
    public void test1479() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1479");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(267759.0f, 429361.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1394240.0f + "'", float2 == 1394240.0f);
    }

    @Test
    public void test1480() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1480");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.375624E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.751248E7f + "'", float2 == 4.751248E7f);
    }

    @Test
    public void test1481() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1481");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 2305580.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.377856E7f + "'", float2 == 7.377856E7f);
    }

    @Test
    public void test1482() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1482");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2045364.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.2851401032634066E7d + "'", double1 == 1.2851401032634066E7d);
    }

    @Test
    public void test1483() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1483");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-604940.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 604940.0f + "'", float2 == 604940.0f);
    }

    @Test
    public void test1484() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1484");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9.567648E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.011530533786615E9d + "'", double1 == 6.011530533786615E9d);
    }

    @Test
    public void test1485() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1485");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6162800.0f, 3.64752E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.5276E7f + "'", float2 == 8.5276E7f);
    }

    @Test
    public void test1486() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1486");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6800.0f, 1352.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 16304.0f + "'", float2 == 16304.0f);
    }

    @Test
    public void test1487() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1487");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-2.667709E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.5876777E9f) + "'", float2 == (-2.5876777E9f));
    }

    @Test
    public void test1488() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1488");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-6.0062864E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3.7738610459192574E8d) + "'", double1 == (-3.7738610459192574E8d));
    }

    @Test
    public void test1489() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1489");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14305.0f, 48672.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 125954.0f + "'", float2 == 125954.0f);
    }

    @Test
    public void test1490() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1490");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-52964.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-332782.6266094596d) + "'", double1 == (-332782.6266094596d));
    }

    @Test
    public void test1491() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1491");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 6506.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 208192.0f + "'", float2 == 208192.0f);
    }

    @Test
    public void test1492() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1492");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(1840313.0f, 0.0f, 359378.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1493() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1493");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.9327112E7f, 441395.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.9537016E7f + "'", float2 == 5.9537016E7f);
    }

    @Test
    public void test1494() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1494");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1267554.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.4364392E7f + "'", float2 == 4.4364392E7f);
    }

    @Test
    public void test1495() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1495");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (float) 0L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1496() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1496");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 2871398.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.785256E8f + "'", float2 == 2.785256E8f);
    }

    @Test
    public void test1497() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1497");
        double double1 = org.example.maths.Perimeter.perimeterCircle(50392.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 316622.2739993937d + "'", double1 == 316622.2739993937d);
    }

    @Test
    public void test1498() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1498");
        double double1 = org.example.maths.Perimeter.perimeterCircle(21340.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 134083.17445521237d + "'", double1 == 134083.17445521237d);
    }

    @Test
    public void test1499() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1499");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9180052.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.767996784554458E7d + "'", double1 == 5.767996784554458E7d);
    }

    @Test
    public void test1500() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1500");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 117.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 11700.0f + "'", float2 == 11700.0f);
    }

    @Test
    public void test1501() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1501");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 42980.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 429800.0f + "'", float2 == 429800.0f);
    }

    @Test
    public void test1502() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1502");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1702207.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0695282012178242E7d + "'", double1 == 1.0695282012178242E7d);
    }

    @Test
    public void test1503() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1503");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4560420.0f), 9920.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9101000.0f) + "'", float2 == (-9101000.0f));
    }

    @Test
    public void test1504() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1504");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5387.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 33847.51924977643d + "'", double1 == 33847.51924977643d);
    }

    @Test
    public void test1505() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1505");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8734442.0f, 173627.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7816138E7f + "'", float2 == 1.7816138E7f);
    }

    @Test
    public void test1506() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1506");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 3449.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 344900.0f + "'", float2 == 344900.0f);
    }

    @Test
    public void test1507() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1507");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 9459089.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.02690848E8f + "'", float2 == 3.02690848E8f);
    }

    @Test
    public void test1508() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1508");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6638.0f, 7185585.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4384446E7f + "'", float2 == 1.4384446E7f);
    }

    @Test
    public void test1509() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1509");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2045364.0f, 505416.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5101560.0f + "'", float2 == 5101560.0f);
    }

    @Test
    public void test1510() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1510");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1.05183632E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.05183631E10f + "'", float2 == 1.05183631E10f);
    }

    @Test
    public void test1511() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1511");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.3190616E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.970383500028273E8d + "'", double1 == 3.970383500028273E8d);
    }

    @Test
    public void test1512() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1512");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9621176.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.045163168098886E7d + "'", double1 == 6.045163168098886E7d);
    }

    @Test
    public void test1513() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1513");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.0f, 2677470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5354942.0f + "'", float2 == 5354942.0f);
    }

    @Test
    public void test1514() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1514");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 6900.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 241500.0f + "'", float2 == 241500.0f);
    }

    @Test
    public void test1515() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1515");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-39416.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-247658.03206779057d) + "'", double1 == (-247658.03206779057d));
    }

    @Test
    public void test1516() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1516");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1.5975563E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.59755635E9f + "'", float2 == 1.59755635E9f);
    }

    @Test
    public void test1517() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1517");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4120771.0f), 939319.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6362904.0f) + "'", float2 == (-6362904.0f));
    }

    @Test
    public void test1518() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1518");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2851037.0f, 1031680.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7765434.0f + "'", float2 == 7765434.0f);
    }

    @Test
    public void test1519() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1519");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 125954.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1520() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1520");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9344420.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.8712722448115066E7d + "'", double1 == 5.8712722448115066E7d);
    }

    @Test
    public void test1521() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1521");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4496007.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.824924512337657E7d + "'", double1 == 2.824924512337657E7d);
    }

    @Test
    public void test1522() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1522");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1718.0f, 170720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 344876.0f + "'", float2 == 344876.0f);
    }

    @Test
    public void test1523() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1523");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6840.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 42976.98750110837d + "'", double1 == 42976.98750110837d);
    }

    @Test
    public void test1524() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1524");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(74096.0f, 826978.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1802148.0f + "'", float2 == 1802148.0f);
    }

    @Test
    public void test1525() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1525");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.92861696E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.468422836060853E9d + "'", double1 == 2.468422836060853E9d);
    }

    @Test
    public void test1526() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1526");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 101000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3232000.0f + "'", float2 == 3232000.0f);
    }

    @Test
    public void test1527() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1527");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5480.0f, 156.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 11272.0f + "'", float2 == 11272.0f);
    }

    @Test
    public void test1528() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1528");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 1425600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1425600.0f + "'", float2 == 1425600.0f);
    }

    @Test
    public void test1529() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1529");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1696240.0f, 5464638.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4321756E7f + "'", float2 == 1.4321756E7f);
    }

    @Test
    public void test1530() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1530");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 1.86445E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.86445E7f) + "'", float2 == (-1.86445E7f));
    }

    @Test
    public void test1531() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1531");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2273546.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.428511082239692E7d + "'", double1 == 1.428511082239692E7d);
    }

    @Test
    public void test1532() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1532");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1933984.0f), 42.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3867884.0f) + "'", float2 == (-3867884.0f));
    }

    @Test
    public void test1533() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1533");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 341530.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-341530.0f) + "'", float2 == (-341530.0f));
    }

    @Test
    public void test1534() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1534");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 14305.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-14305.0f) + "'", float2 == (-14305.0f));
    }

    @Test
    public void test1535() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1535");
        double double1 = org.example.maths.Perimeter.perimeterCircle(16768.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 105356.45123078731d + "'", double1 == 105356.45123078731d);
    }

    @Test
    public void test1536() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1536");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.6955768E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.206954977285251E8d + "'", double1 == 4.206954977285251E8d);
    }

    @Test
    public void test1537() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1537");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1538() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1538");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 26488.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2569336.0f + "'", float2 == 2569336.0f);
    }

    @Test
    public void test1539() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1539");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-899931.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5654433.236675432d) + "'", double1 == (-5654433.236675432d));
    }

    @Test
    public void test1540() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1540");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2240.0f + "'", float2 == 2240.0f);
    }

    @Test
    public void test1541() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1541");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(798.0f, (-14890.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-28184.0f) + "'", float2 == (-28184.0f));
    }

    @Test
    public void test1542() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1542");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8999310.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.654433236675432E7d) + "'", double1 == (-5.654433236675432E7d));
    }

    @Test
    public void test1543() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1543");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5480.0f, (-6312.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1664.0f) + "'", float2 == (-1664.0f));
    }

    @Test
    public void test1544() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1544");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1.189078E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.189078E8f + "'", float2 == 1.189078E8f);
    }

    @Test
    public void test1545() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1545");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(50132.0f, 4000862.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8101988.0f + "'", float2 == 8101988.0f);
    }

    @Test
    public void test1546() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1546");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.152952E7f, (-1.8621926E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5815188.0f + "'", float2 == 5815188.0f);
    }

    @Test
    public void test1547() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1547");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 429361.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 429361.0f + "'", float2 == 429361.0f);
    }

    @Test
    public void test1548() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1548");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 285176.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.85176E7f + "'", float2 == 2.85176E7f);
    }

    @Test
    public void test1549() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1549");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 1.5975563E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.11218016E8f + "'", float2 == 5.11218016E8f);
    }

    @Test
    public void test1550() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1550");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1.2094254E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.20942541E9f + "'", float2 == 1.20942541E9f);
    }

    @Test
    public void test1551() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1551");
        double double1 = org.example.maths.Perimeter.perimeterCircle(537271.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3375773.2531736833d + "'", double1 == 3375773.2531736833d);
    }

    @Test
    public void test1552() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1552");
        double double1 = org.example.maths.Perimeter.perimeterCircle(10531.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 66168.22446990822d + "'", double1 == 66168.22446990822d);
    }

    @Test
    public void test1553() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1553");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(211186.0f, 2538165.0f, 89756.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1554() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1554");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1031680.0f, 7783474.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7630308E7f + "'", float2 == 1.7630308E7f);
    }

    @Test
    public void test1555() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1555");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4228.0f, (-1473395.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2938334.0f) + "'", float2 == (-2938334.0f));
    }

    @Test
    public void test1556() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1556");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4940.0f), (-7.16004E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.43210688E8f) + "'", float2 == (-1.43210688E8f));
    }

    @Test
    public void test1557() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1557");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(173627.0f, 3.500342E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.0354096E7f + "'", float2 == 7.0354096E7f);
    }

    @Test
    public void test1558() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1558");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.78122432E8f, 45784.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.5633645E8f + "'", float2 == 5.5633645E8f);
    }

    @Test
    public void test1559() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1559");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.4321756E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.998624687221108E7d + "'", double1 == 8.998624687221108E7d);
    }

    @Test
    public void test1560() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1560");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(392434.0f, 8.6611251E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.73300992E9f + "'", float2 == 1.73300992E9f);
    }

    @Test
    public void test1561() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1561");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, (-3.01170688E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.01170688E8f) + "'", float2 == (-3.01170688E8f));
    }

    @Test
    public void test1562() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1562");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-39515.0f), (-93500.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-266030.0f) + "'", float2 == (-266030.0f));
    }

    @Test
    public void test1563() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1563");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.3164008E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.34039313936378E8d + "'", double1 == 3.34039313936378E8d);
    }

    @Test
    public void test1564() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1564");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.7642896E7f), (-9.8820314E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.15169203E9f) + "'", float2 == (-2.15169203E9f));
    }

    @Test
    public void test1565() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1565");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1.0162545E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.01625453E9f + "'", float2 == 1.01625453E9f);
    }

    @Test
    public void test1566() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1566");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (float) (byte) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.0f + "'", float2 == 2.0f);
    }

    @Test
    public void test1567() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1567");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(597605.0f, 234018.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1663246.0f + "'", float2 == 1663246.0f);
    }

    @Test
    public void test1568() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1568");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 1.7462434E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.0804659E8f + "'", float2 == 9.0804659E8f);
    }

    @Test
    public void test1569() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1569");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-35.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-219.9114857512855d) + "'", double1 == (-219.9114857512855d));
    }

    @Test
    public void test1570() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1570");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 597605.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5976050.0f + "'", float2 == 5976050.0f);
    }

    @Test
    public void test1571() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1571");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7.161804E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.499894166569999E8d + "'", double1 == 4.499894166569999E8d);
    }

    @Test
    public void test1572() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1572");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.6579384E9f), 5.5918932E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.2040387E9f) + "'", float2 == (-9.2040387E9f));
    }

    @Test
    public void test1573() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1573");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(144742.0f, 5742080.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1773644E7f + "'", float2 == 1.1773644E7f);
    }

    @Test
    public void test1574() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1574");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(100.0f, (float) (-1));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 198.0f + "'", float2 == 198.0f);
    }

    @Test
    public void test1575() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1575");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 4672052.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.672052E7f + "'", float2 == 4.672052E7f);
    }

    @Test
    public void test1576() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1576");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.24858352E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4128266934830155E9d) + "'", double1 == (-1.4128266934830155E9d));
    }

    @Test
    public void test1577() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1577");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-164.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 164.0f + "'", float2 == 164.0f);
    }

    @Test
    public void test1578() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1578");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-384348.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2414929.7064438597d) + "'", double1 == (-2414929.7064438597d));
    }

    @Test
    public void test1579() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1579");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(41459.0f, 117592.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 318102.0f + "'", float2 == 318102.0f);
    }

    @Test
    public void test1580() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1580");
        double double1 = org.example.maths.Perimeter.perimeterCircle(524175.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3293488.6583908596d + "'", double1 == 3293488.6583908596d);
    }

    @Test
    public void test1581() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1581");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-21593.0f), 179689.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 316192.0f + "'", float2 == 316192.0f);
    }

    @Test
    public void test1582() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1582");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 318916.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.0934852E7f + "'", float2 == 3.0934852E7f);
    }

    @Test
    public void test1583() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1583");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 41459.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-41459.0f) + "'", float2 == (-41459.0f));
    }

    @Test
    public void test1584() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1584");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5.8661552E7f, 14722.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.17352544E8f + "'", float2 == 1.17352544E8f);
    }

    @Test
    public void test1585() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1585");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 597605.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1195210.0f + "'", float2 == 1195210.0f);
    }

    @Test
    public void test1586() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1586");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 2304000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.304E7f + "'", float2 == 2.304E7f);
    }

    @Test
    public void test1587() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1587");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.279548E8f, 4493662.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.64896928E8f + "'", float2 == 2.64896928E8f);
    }

    @Test
    public void test1588() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1588");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(297144.0f, 16.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 594320.0f + "'", float2 == 594320.0f);
    }

    @Test
    public void test1589() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1589");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.27959576E8f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.55919152E8f) + "'", float2 == (-2.55919152E8f));
    }

    @Test
    public void test1590() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1590");
        double double1 = org.example.maths.Perimeter.perimeterCircle(234018.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1470378.4592155523d + "'", double1 == 1470378.4592155523d);
    }

    @Test
    public void test1591() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1591");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-369712.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2322969.006287979d) + "'", double1 == (-2322969.006287979d));
    }

    @Test
    public void test1592() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1592");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(17020.0f, 604940.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1243920.0f + "'", float2 == 1243920.0f);
    }

    @Test
    public void test1593() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1593");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9076.0f, 3.92861696E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.8574157E8f + "'", float2 == 7.8574157E8f);
    }

    @Test
    public void test1594() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1594");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(907600.0f, 158368.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2131936.0f + "'", float2 == 2131936.0f);
    }

    @Test
    public void test1595() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1595");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(500675.0f, (-52861.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 895628.0f + "'", float2 == 895628.0f);
    }

    @Test
    public void test1596() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1596");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(594288.0f, 4400194.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9988964.0f + "'", float2 == 9988964.0f);
    }

    @Test
    public void test1597() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1597");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 170720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8877440.0f + "'", float2 == 8877440.0f);
    }

    @Test
    public void test1598() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1598");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.10038E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.9480262062673447E8d + "'", double1 == 1.9480262062673447E8d);
    }

    @Test
    public void test1599() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1599");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 2067892.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.067892E8f + "'", float2 == 2.067892E8f);
    }

    @Test
    public void test1600() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1600");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9144.0f, 1426376.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2871040.0f + "'", float2 == 2871040.0f);
    }

    @Test
    public void test1601() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1601");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4055119.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.5479064119664777E7d) + "'", double1 == (-2.5479064119664777E7d));
    }

    @Test
    public void test1602() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1602");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 5.8661552E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.05040077E9f + "'", float2 == 3.05040077E9f);
    }

    @Test
    public void test1603() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1603");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-12170.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1604() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1604");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-9.2040387E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.2040387E9f + "'", float2 == 9.2040387E9f);
    }

    @Test
    public void test1605() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1605");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 3.500342E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.500342E7f) + "'", float2 == (-3.500342E7f));
    }

    @Test
    public void test1606() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1606");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1496110.0f), 3345696.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3699172.0f + "'", float2 == 3699172.0f);
    }

    @Test
    public void test1607() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1607");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 2.72571E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.72571E7f + "'", float2 == 2.72571E7f);
    }

    @Test
    public void test1608() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1608");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1597452.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1609() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1609");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-7.16004E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1610() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1610");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-196.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10192.0f) + "'", float2 == (-10192.0f));
    }

    @Test
    public void test1611() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1611");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-9.8820312E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6.209063324093026E8d) + "'", double1 == (-6.209063324093026E8d));
    }

    @Test
    public void test1612() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1612");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-2437.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-24370.0f) + "'", float2 == (-24370.0f));
    }

    @Test
    public void test1613() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1613");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 3.3479134E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.34791347E9f + "'", float2 == 3.34791347E9f);
    }

    @Test
    public void test1614() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1614");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-19300.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1930000.0f) + "'", float2 == (-1930000.0f));
    }

    @Test
    public void test1615() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1615");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-1.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.0f) + "'", float2 == (-1.0f));
    }

    @Test
    public void test1616() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1616");
        double double1 = org.example.maths.Perimeter.perimeterCircle(429708.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2699934.9919775254d + "'", double1 == 2699934.9919775254d);
    }

    @Test
    public void test1617() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1617");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3699172.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.3242583159130123E7d + "'", double1 == 2.3242583159130123E7d);
    }

    @Test
    public void test1618() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1618");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.8621926E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1700501183458552E8d + "'", double1 == 1.1700501183458552E8d);
    }

    @Test
    public void test1619() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1619");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 4400194.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1620() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1620");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 2871398.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.871398E7f + "'", float2 == 2.871398E7f);
    }

    @Test
    public void test1621() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1621");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(297144.0f, 36086.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 666460.0f + "'", float2 == 666460.0f);
    }

    @Test
    public void test1622() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1622");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(629860.0f, 21265.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1302250.0f + "'", float2 == 1302250.0f);
    }

    @Test
    public void test1623() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1623");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1797.0f, 438.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4470.0f + "'", float2 == 4470.0f);
    }

    @Test
    public void test1624() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1624");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86076.0f, (-14812.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 142528.0f + "'", float2 == 142528.0f);
    }

    @Test
    public void test1625() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1625");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-2.5876777E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.58767766E11f) + "'", float2 == (-2.58767766E11f));
    }

    @Test
    public void test1626() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1626");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-5.7127224E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.7127224E7f + "'", float2 == 5.7127224E7f);
    }

    @Test
    public void test1627() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1627");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(961904.0f, 6162800.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4249408E7f + "'", float2 == 1.4249408E7f);
    }

    @Test
    public void test1628() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1628");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9459089.0f, 2301926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.352203E7f + "'", float2 == 2.352203E7f);
    }

    @Test
    public void test1629() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1629");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.563036E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-9.820844829792751E7d) + "'", double1 == (-9.820844829792751E7d));
    }

    @Test
    public void test1630() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1630");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-3.6826432E9f), (-944.0f), 627984.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1631() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1631");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1061.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 37135.0f + "'", float2 == 37135.0f);
    }

    @Test
    public void test1632() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1632");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3953000.0f), 801055.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6303890.0f) + "'", float2 == (-6303890.0f));
    }

    @Test
    public void test1633() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1633");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1634() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1634");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(40.0f, (-2320.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4560.0f) + "'", float2 == (-4560.0f));
    }

    @Test
    public void test1635() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1635");
        double double1 = org.example.maths.Perimeter.perimeterCircle(28.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 175.92918860102841d + "'", double1 == 175.92918860102841d);
    }

    @Test
    public void test1636() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1636");
        double double1 = org.example.maths.Perimeter.perimeterCircle(88976.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 559052.6958916108d + "'", double1 == 559052.6958916108d);
    }

    @Test
    public void test1637() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1637");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 88576.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2834432.0f + "'", float2 == 2834432.0f);
    }

    @Test
    public void test1638() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1638");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-39530.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-248374.31519280904d) + "'", double1 == (-248374.31519280904d));
    }

    @Test
    public void test1639() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1639");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.72976E7f, 18124.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.4631448E7f + "'", float2 == 7.4631448E7f);
    }

    @Test
    public void test1640() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1640");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7292.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 45816.987259953545d + "'", double1 == 45816.987259953545d);
    }

    @Test
    public void test1641() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1641");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(71453.0f, 620540.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1383986.0f + "'", float2 == 1383986.0f);
    }

    @Test
    public void test1642() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1642");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-6852680.0f), 1031680.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.1642E7f) + "'", float2 == (-1.1642E7f));
    }

    @Test
    public void test1643() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1643");
        double double1 = org.example.maths.Perimeter.perimeterCircle(324254.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2037347.9685942095d + "'", double1 == 2037347.9685942095d);
    }

    @Test
    public void test1644() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1644");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(163334.0f, 3.2210262E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.4747192E7f + "'", float2 == 6.4747192E7f);
    }

    @Test
    public void test1645() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1645");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.728902E7f, 441395.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.5460832E7f + "'", float2 == 7.5460832E7f);
    }

    @Test
    public void test1646() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1646");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.7370192E8f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.4740384E8f) + "'", float2 == (-3.4740384E8f));
    }

    @Test
    public void test1647() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1647");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 3.2123278E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.21232768E8f + "'", float2 == 3.21232768E8f);
    }

    @Test
    public void test1648() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1648");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1.60946E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.60945997E9f + "'", float2 == 1.60945997E9f);
    }

    @Test
    public void test1649() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1649");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(101000.0f, 504400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1210800.0f + "'", float2 == 1210800.0f);
    }

    @Test
    public void test1650() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1650");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-1980000.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1980000.0f + "'", float2 == 1980000.0f);
    }

    @Test
    public void test1651() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1651");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1438.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 143800.0f + "'", float2 == 143800.0f);
    }

    @Test
    public void test1652() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1652");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7617075.0f, 37135.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.530842E7f + "'", float2 == 1.530842E7f);
    }

    @Test
    public void test1653() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1653");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.854835E7f, (-2.55742912E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.7438912E8f) + "'", float2 == (-4.7438912E8f));
    }

    @Test
    public void test1654() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1654");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86064.0f, 2136520.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4445168.0f + "'", float2 == 4445168.0f);
    }

    @Test
    public void test1655() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1655");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1496110.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2992220.0f) + "'", float2 == (-2992220.0f));
    }

    @Test
    public void test1656() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1656");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-6303890.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6303890.0f) + "'", float2 == (-6303890.0f));
    }

    @Test
    public void test1657() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1657");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(510.0f, 414960.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 830940.0f + "'", float2 == 830940.0f);
    }

    @Test
    public void test1658() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1658");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(666460.0f, 944115.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3221150.0f + "'", float2 == 3221150.0f);
    }

    @Test
    public void test1659() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1659");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(304064.0f, (-4.09935296E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.1926246E8f) + "'", float2 == (-8.1926246E8f));
    }

    @Test
    public void test1660() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1660");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-6839721.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4.2975234492407665E7d) + "'", double1 == (-4.2975234492407665E7d));
    }

    @Test
    public void test1661() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1661");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-1900442.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1662() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1662");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.74969568E8f), 16768.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.499056E8f) + "'", float2 == (-5.499056E8f));
    }

    @Test
    public void test1663() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1663");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3449.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 21670.706124462395d + "'", double1 == 21670.706124462395d);
    }

    @Test
    public void test1664() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1664");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-998191.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.4936684E7f) + "'", float2 == (-3.4936684E7f));
    }

    @Test
    public void test1665() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1665");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-441395.0f), 2131936.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3381082.0f + "'", float2 == 3381082.0f);
    }

    @Test
    public void test1666() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1666");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7.377856E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.6356436417686754E8d + "'", double1 == 4.6356436417686754E8d);
    }

    @Test
    public void test1667() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1667");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(503920.0f, (-1150826.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1293812.0f) + "'", float2 == (-1293812.0f));
    }

    @Test
    public void test1668() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1668");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 88924.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1669() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1669");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1334160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1334160.0f + "'", float2 == 1334160.0f);
    }

    @Test
    public void test1670() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1670");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8.5899504E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.397225014268141E8d) + "'", double1 == (-5.397225014268141E8d));
    }

    @Test
    public void test1671() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1671");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 4496007.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.49600704E8f + "'", float2 == 4.49600704E8f);
    }

    @Test
    public void test1672() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1672");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.51039904E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.577330236328574E9d) + "'", double1 == (-1.577330236328574E9d));
    }

    @Test
    public void test1673() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1673");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85980.0f, 1375069.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2922098.0f + "'", float2 == 2922098.0f);
    }

    @Test
    public void test1674() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1674");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2851760.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.7918136531602457E7d + "'", double1 == 1.7918136531602457E7d);
    }

    @Test
    public void test1675() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1675");
        double double1 = org.example.maths.Perimeter.perimeterCircle(21133.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 132782.5550966262d + "'", double1 == 132782.5550966262d);
    }

    @Test
    public void test1676() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1676");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8.578004E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.389718869772772E8d) + "'", double1 == (-5.389718869772772E8d));
    }

    @Test
    public void test1677() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1677");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.89376128E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8182038356981192E9d + "'", double1 == 1.8182038356981192E9d);
    }

    @Test
    public void test1678() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1678");
        double double1 = org.example.maths.Perimeter.perimeterCircle(359343.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2257818.657837834d + "'", double1 == 2257818.657837834d);
    }

    @Test
    public void test1679() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1679");
        double double1 = org.example.maths.Perimeter.perimeterCircle(41496.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 260727.05750672412d + "'", double1 == 260727.05750672412d);
    }

    @Test
    public void test1680() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1680");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8800.0f), (-3.1202344E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.2422288E7f) + "'", float2 == (-6.2422288E7f));
    }

    @Test
    public void test1681() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1681");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2235184.0f, 144742.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4759852.0f + "'", float2 == 4759852.0f);
    }

    @Test
    public void test1682() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1682");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1560770.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1683() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1683");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 3635851.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.27254784E8f + "'", float2 == 1.27254784E8f);
    }

    @Test
    public void test1684() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1684");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(39515.0f, 3663.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 86356.0f + "'", float2 == 86356.0f);
    }

    @Test
    public void test1685() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1685");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(800846.0f, 1000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1603692.0f + "'", float2 == 1603692.0f);
    }

    @Test
    public void test1686() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1686");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-57598.0f), 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-115064.0f) + "'", float2 == (-115064.0f));
    }

    @Test
    public void test1687() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1687");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1638123.0f, 784840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4845926.0f + "'", float2 == 4845926.0f);
    }

    @Test
    public void test1688() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1688");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5.9842952E7f), 738.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.19684432E8f) + "'", float2 == (-1.19684432E8f));
    }

    @Test
    public void test1689() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1689");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.4384446E7f, 2028300.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.2825492E7f + "'", float2 == 3.2825492E7f);
    }

    @Test
    public void test1690() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1690");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-1664.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-166400.0f) + "'", float2 == (-166400.0f));
    }

    @Test
    public void test1691() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1691");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(18.0f, (-2118.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4200.0f) + "'", float2 == (-4200.0f));
    }

    @Test
    public void test1692() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1692");
        double double1 = org.example.maths.Perimeter.perimeterCircle(189999.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1193798.9251788142d + "'", double1 == 1193798.9251788142d);
    }

    @Test
    public void test1693() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1693");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 2758160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4342432E8f + "'", float2 == 1.4342432E8f);
    }

    @Test
    public void test1694() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1694");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5731998.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.601520561438277E7d + "'", double1 == 3.601520561438277E7d);
    }

    @Test
    public void test1695() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1695");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.8515E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.4199688210602176E8d) + "'", double1 == (-2.4199688210602176E8d));
    }

    @Test
    public void test1696() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1696");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.1913613E8f), 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.63819507E9f) + "'", float2 == (-1.63819507E9f));
    }

    @Test
    public void test1697() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1697");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2396175.0f, (-88.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4792174.0f + "'", float2 == 4792174.0f);
    }

    @Test
    public void test1698() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1698");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.27964392E8f, (-2.3641006E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.08646768E8f + "'", float2 == 2.08646768E8f);
    }

    @Test
    public void test1699() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1699");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1486164.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9337843.808859242d + "'", double1 == 9337843.808859242d);
    }

    @Test
    public void test1700() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1700");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.27948472E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.039239593464787E8d + "'", double1 == 8.039239593464787E8d);
    }

    @Test
    public void test1701() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1701");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9700.0f, 1120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 21640.0f + "'", float2 == 21640.0f);
    }

    @Test
    public void test1702() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1702");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-1.86445E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1703() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1703");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-71012.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 71012.0f + "'", float2 == 71012.0f);
    }

    @Test
    public void test1704() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1704");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 1570708.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1570708.0f) + "'", float2 == (-1570708.0f));
    }

    @Test
    public void test1705() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1705");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 302342.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1706() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1706");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 9459089.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.4590893E8f + "'", float2 == 9.4590893E8f);
    }

    @Test
    public void test1707() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1707");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-42.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1708() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1708");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.68801E7f, 915698.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.55916E7f + "'", float2 == 9.55916E7f);
    }

    @Test
    public void test1709() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1709");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 1397915.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.397915E7f + "'", float2 == 1.397915E7f);
    }

    @Test
    public void test1710() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1710");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.89376128E8f, (-363742.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.7802477E8f + "'", float2 == 5.7802477E8f);
    }

    @Test
    public void test1711() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1711");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-7.3653658E9f), 2758160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.47252152E10f) + "'", float2 == (-1.47252152E10f));
    }

    @Test
    public void test1712() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1712");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 42.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 42.0f + "'", float2 == 42.0f);
    }

    @Test
    public void test1713() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1713");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4075701.0f), 5818962.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3486522.0f + "'", float2 == 3486522.0f);
    }

    @Test
    public void test1714() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1714");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-7703000.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4.839937642120435E7d) + "'", double1 == (-4.839937642120435E7d));
    }

    @Test
    public void test1715() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1715");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(530.0f, (-113350.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-225640.0f) + "'", float2 == (-225640.0f));
    }

    @Test
    public void test1716() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1716");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.2188646E8f), 137160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.64349862E9f) + "'", float2 == (-1.64349862E9f));
    }

    @Test
    public void test1717() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1717");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2301926.0f), 1.5975563E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.7347274E7f + "'", float2 == 2.7347274E7f);
    }

    @Test
    public void test1718() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1718");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-42.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-420.0f) + "'", float2 == (-420.0f));
    }

    @Test
    public void test1719() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1719");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(172.0f, 1340698.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2681740.0f + "'", float2 == 2681740.0f);
    }

    @Test
    public void test1720() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1720");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 8634283.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.4898272E8f + "'", float2 == 4.4898272E8f);
    }

    @Test
    public void test1721() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1721");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4091280.0f), 1302250.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5578060.0f) + "'", float2 == (-5578060.0f));
    }

    @Test
    public void test1722() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1722");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 80911.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8091100.0f + "'", float2 == 8091100.0f);
    }

    @Test
    public void test1723() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1723");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1788090.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1234900815914746E7d + "'", double1 == 1.1234900815914746E7d);
    }

    @Test
    public void test1724() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1724");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2206.0f, 888126.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1780664.0f + "'", float2 == 1780664.0f);
    }

    @Test
    public void test1725() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1725");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 4.6579384E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.51820028E11f + "'", float2 == 4.51820028E11f);
    }

    @Test
    public void test1726() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1726");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.294496E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.9549484783300674E8d + "'", double1 == 3.9549484783300674E8d);
    }

    @Test
    public void test1727() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1727");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(468.0f, 2394591.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4790118.0f + "'", float2 == 4790118.0f);
    }

    @Test
    public void test1728() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1728");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-1150753.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2301506.0f) + "'", float2 == (-2301506.0f));
    }

    @Test
    public void test1729() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1729");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.8621926E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.1700501183458552E8d) + "'", double1 == (-1.1700501183458552E8d));
    }

    @Test
    public void test1730() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1730");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-3.0521238E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.0521238E7f) + "'", float2 == (-3.0521238E7f));
    }

    @Test
    public void test1731() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1731");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 2569336.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2569336.0f) + "'", float2 == (-2569336.0f));
    }

    @Test
    public void test1732() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1732");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(718.0f, (-8.1281222E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.62562304E9f) + "'", float2 == (-1.62562304E9f));
    }

    @Test
    public void test1733() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1733");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.5756495E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.900097787664862E7d + "'", double1 == 9.900097787664862E7d);
    }

    @Test
    public void test1734() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1734");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-22504.0f), (-127940.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-300888.0f) + "'", float2 == (-300888.0f));
    }

    @Test
    public void test1735() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1735");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4.3048544E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.7048197915627396E8d) + "'", double1 == (-2.7048197915627396E8d));
    }

    @Test
    public void test1736() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1736");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3303707.0f, 2.59274112E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.25155648E8f + "'", float2 == 5.25155648E8f);
    }

    @Test
    public void test1737() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1737");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-8222434.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1738() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1738");
        double double1 = org.example.maths.Perimeter.perimeterCircle(367783.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2310848.74183043d + "'", double1 == 2310848.74183043d);
    }

    @Test
    public void test1739() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1739");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 10531.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1740() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1740");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-200474.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1259615.2912715203d) + "'", double1 == (-1259615.2912715203d));
    }

    @Test
    public void test1741() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1741");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, (-3.4740384E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.4740384E8f) + "'", float2 == (-3.4740384E8f));
    }

    @Test
    public void test1742() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1742");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1375069.0f, 1.7742086E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.8234312E7f + "'", float2 == 3.8234312E7f);
    }

    @Test
    public void test1743() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1743");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.05293424E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.289896625337389E9d) + "'", double1 == (-1.289896625337389E9d));
    }

    @Test
    public void test1744() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1744");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 10.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 100.0f + "'", float2 == 100.0f);
    }

    @Test
    public void test1745() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1745");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2724938.0f, 1.45560576E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.9657104E8f + "'", float2 == 2.9657104E8f);
    }

    @Test
    public void test1746() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1746");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 86356.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1747() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1747");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4.08518944E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.5668002266453204E9d) + "'", double1 == (-2.5668002266453204E9d));
    }

    @Test
    public void test1748() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1748");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 1.28386E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.28386E8f + "'", float2 == 1.28386E8f);
    }

    @Test
    public void test1749() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1749");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 1438.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1438.0f) + "'", float2 == (-1438.0f));
    }

    @Test
    public void test1750() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1750");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 173627.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1751() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1751");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.2737056E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.3135669540310705E8d + "'", double1 == 3.3135669540310705E8d);
    }

    @Test
    public void test1752() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1752");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.3479134E7f, 4462487.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.588324E7f + "'", float2 == 7.588324E7f);
    }

    @Test
    public void test1753() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1753");
        double double1 = org.example.maths.Perimeter.perimeterCircle(387820.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2436744.925830387d + "'", double1 == 2436744.925830387d);
    }

    @Test
    public void test1754() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1754");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(195344.0f, 45784.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 482256.0f + "'", float2 == 482256.0f);
    }

    @Test
    public void test1755() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1755");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.2078448E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.589112700713266E7d + "'", double1 == 7.589112700713266E7d);
    }

    @Test
    public void test1756() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1756");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 359378.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 718756.0f + "'", float2 == 718756.0f);
    }

    @Test
    public void test1757() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1757");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-193.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1212.6547642856601d) + "'", double1 == (-1212.6547642856601d));
    }

    @Test
    public void test1758() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1758");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-68008.0f), 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-58800.0f) + "'", float2 == (-58800.0f));
    }

    @Test
    public void test1759() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1759");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(8863120.0f, (-899309.0f), (-4075701.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1760() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1760");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-99506.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-625214.6371762119d) + "'", double1 == (-625214.6371762119d));
    }

    @Test
    public void test1761() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1761");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2915248.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8317043400384676E7d + "'", double1 == 1.8317043400384676E7d);
    }

    @Test
    public void test1762() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1762");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8520.0f, 2320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 21680.0f + "'", float2 == 21680.0f);
    }

    @Test
    public void test1763() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1763");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-5270.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-511190.0f) + "'", float2 == (-511190.0f));
    }

    @Test
    public void test1764() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1764");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.8311226E7f, 804707.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.8231864E7f + "'", float2 == 3.8231864E7f);
    }

    @Test
    public void test1765() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1765");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-2320.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1766() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1766");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8.6086963E8f, (-7.701672E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.56770586E9f + "'", float2 == 1.56770586E9f);
    }

    @Test
    public void test1767() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1767");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 154588.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4995036E7f + "'", float2 == 1.4995036E7f);
    }

    @Test
    public void test1768() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1768");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(269824.0f, (-177152.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 185344.0f + "'", float2 == 185344.0f);
    }

    @Test
    public void test1769() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1769");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-29.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1015.0f) + "'", float2 == (-1015.0f));
    }

    @Test
    public void test1770() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1770");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3699172.0f, (-2.38225536E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.69052736E8f) + "'", float2 == (-4.69052736E8f));
    }

    @Test
    public void test1771() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1771");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 167840.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-167840.0f) + "'", float2 == (-167840.0f));
    }

    @Test
    public void test1772() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1772");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8.6086963E8f, (-2.054972E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.31074483E9f + "'", float2 == 1.31074483E9f);
    }

    @Test
    public void test1773() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1773");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2970944.0f, (-6696711.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7451534.0f) + "'", float2 == (-7451534.0f));
    }

    @Test
    public void test1774() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1774");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-39416.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3823352.0f) + "'", float2 == (-3823352.0f));
    }

    @Test
    public void test1775() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1775");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-71012.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-446181.5550334368d) + "'", double1 == (-446181.5550334368d));
    }

    @Test
    public void test1776() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1776");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-4.69052736E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1777() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1777");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6162800.0f, (-8.578004E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.5923448E8f) + "'", float2 == (-1.5923448E8f));
    }

    @Test
    public void test1778() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1778");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6550370.0f, (float) 100L);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.310094E7f + "'", float2 == 1.310094E7f);
    }

    @Test
    public void test1779() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1779");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.38225536E8f), 2.59274112E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.2097152E7f + "'", float2 == 4.2097152E7f);
    }

    @Test
    public void test1780() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1780");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20283.0f, (-42097.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-43628.0f) + "'", float2 == (-43628.0f));
    }

    @Test
    public void test1781() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1781");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 18124.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-18124.0f) + "'", float2 == (-18124.0f));
    }

    @Test
    public void test1782() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1782");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1570708.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-9869049.427469434d) + "'", double1 == (-9869049.427469434d));
    }

    @Test
    public void test1783() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1783");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85398.0f, 594320.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1359436.0f + "'", float2 == 1359436.0f);
    }

    @Test
    public void test1784() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1784");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.9657104E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8634108010629694E9d + "'", double1 == 1.8634108010629694E9d);
    }

    @Test
    public void test1785() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1785");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42192.0f, 1.05915546E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.11839526E9f + "'", float2 == 2.11839526E9f);
    }

    @Test
    public void test1786() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1786");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.81953056E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.7715632987735832E9d) + "'", double1 == (-1.7715632987735832E9d));
    }

    @Test
    public void test1787() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1787");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-3867884.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.867884E7f) + "'", float2 == (-3.867884E7f));
    }

    @Test
    public void test1788() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1788");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 1486164.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.486164E7f + "'", float2 == 1.486164E7f);
    }

    @Test
    public void test1789() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1789");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 170635.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.70635E7f + "'", float2 == 1.70635E7f);
    }

    @Test
    public void test1790() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1790");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-93500.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-587477.8262212913d) + "'", double1 == (-587477.8262212913d));
    }

    @Test
    public void test1791() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1791");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.545805E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.5995764570944327E8d + "'", double1 == 1.5995764570944327E8d);
    }

    @Test
    public void test1792() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1792");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1933984.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.2151579853120405E7d) + "'", double1 == (-1.2151579853120405E7d));
    }

    @Test
    public void test1793() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1793");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-200474.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.00474E7f) + "'", float2 == (-2.00474E7f));
    }

    @Test
    public void test1794() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1794");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-6696711.0f), 2304000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8785422.0f) + "'", float2 == (-8785422.0f));
    }

    @Test
    public void test1795() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1795");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4661946.0f, 1.3377472E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.6078836E7f + "'", float2 == 3.6078836E7f);
    }

    @Test
    public void test1796() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1796");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 8120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 16240.0f + "'", float2 == 16240.0f);
    }

    @Test
    public void test1797() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1797");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1150826.0f), 208192.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1885268.0f) + "'", float2 == (-1885268.0f));
    }

    @Test
    public void test1798() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1798");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1228.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7715.751557216532d + "'", double1 == 7715.751557216532d);
    }

    @Test
    public void test1799() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1799");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(66317.0f, (-3016.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 126602.0f + "'", float2 == 126602.0f);
    }

    @Test
    public void test1800() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1800");
        double double1 = org.example.maths.Perimeter.perimeterCircle(777062.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4882424.541167583d + "'", double1 == 4882424.541167583d);
    }

    @Test
    public void test1801() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1801");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-2.6149806E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.61498061E9f) + "'", float2 == (-2.61498061E9f));
    }

    @Test
    public void test1802() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1802");
        double double1 = org.example.maths.Perimeter.perimeterCircle(26024.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 163513.61443404155d + "'", double1 == 163513.61443404155d);
    }

    @Test
    public void test1803() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1803");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.7462434E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0971970873639326E8d + "'", double1 == 1.0971970873639326E8d);
    }

    @Test
    public void test1804() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1804");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 5600.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1805() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1805");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.74256992E8f, 29702.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.4857338E8f + "'", float2 == 9.4857338E8f);
    }

    @Test
    public void test1806() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1806");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 558815.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.58815E7f + "'", float2 == 5.58815E7f);
    }

    @Test
    public void test1807() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1807");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6716409.0f, (-1.1642E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9851182.0f) + "'", float2 == (-9851182.0f));
    }

    @Test
    public void test1808() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1808");
        double double1 = org.example.maths.Perimeter.perimeterCircle(37135.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 233326.08638211392d + "'", double1 == 233326.08638211392d);
    }

    @Test
    public void test1809() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1809");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.9896E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.9792E7f + "'", float2 == 9.9792E7f);
    }

    @Test
    public void test1810() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1810");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(858394.0f, (-1.19684432E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.3765208E8f) + "'", float2 == (-2.3765208E8f));
    }

    @Test
    public void test1811() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1811");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-2056880.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2056880.0f + "'", float2 == 2056880.0f);
    }

    @Test
    public void test1812() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1812");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.6981038E7f, (-3348107.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.7265862E7f + "'", float2 == 2.7265862E7f);
    }

    @Test
    public void test1813() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1813");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3340.0f, 84220.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 175120.0f + "'", float2 == 175120.0f);
    }

    @Test
    public void test1814() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1814");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1.05183631E10f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1815() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1815");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1021580.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6418776.446108522d + "'", double1 == 6418776.446108522d);
    }

    @Test
    public void test1816() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1816");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 11272.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1127200.0f + "'", float2 == 1127200.0f);
    }

    @Test
    public void test1817() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1817");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.067892E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.299294863123421E9d + "'", double1 == 1.299294863123421E9d);
    }

    @Test
    public void test1818() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1818");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-1.79390624E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.74008914E10f) + "'", float2 == (-1.74008914E10f));
    }

    @Test
    public void test1819() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1819");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-2.264892E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.2648919E9f) + "'", float2 == (-2.2648919E9f));
    }

    @Test
    public void test1820() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1820");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-0.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1821() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1821");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2575.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 16179.202165987435d + "'", double1 == 16179.202165987435d);
    }

    @Test
    public void test1822() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1822");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 1210013.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1210013.0f + "'", float2 == 1210013.0f);
    }

    @Test
    public void test1823() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1823");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9137503.0f, (-422768.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.742947E7f + "'", float2 == 1.742947E7f);
    }

    @Test
    public void test1824() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1824");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-70376.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 70376.0f + "'", float2 == 70376.0f);
    }

    @Test
    public void test1825() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1825");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-7642758.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4.802086477192924E7d) + "'", double1 == (-4.802086477192924E7d));
    }

    @Test
    public void test1826() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1826");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 820429.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.2042896E7f + "'", float2 == 8.2042896E7f);
    }

    @Test
    public void test1827() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1827");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-29.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 29.0f + "'", float2 == 29.0f);
    }

    @Test
    public void test1828() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1828");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.6233988E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.533285671657132E8d + "'", double1 == 3.533285671657132E8d);
    }

    @Test
    public void test1829() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1829");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1479881.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1479881.0f + "'", float2 == 1479881.0f);
    }

    @Test
    public void test1830() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1830");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(318102.0f, (-14812.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 606580.0f + "'", float2 == 606580.0f);
    }

    @Test
    public void test1831() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1831");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(801186.0f, 232985.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2068342.0f + "'", float2 == 2068342.0f);
    }

    @Test
    public void test1832() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1832");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21593.0f, 6.2943896E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.25930976E8f + "'", float2 == 1.25930976E8f);
    }

    @Test
    public void test1833() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1833");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8800.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-55292.03070318036d) + "'", double1 == (-55292.03070318036d));
    }

    @Test
    public void test1834() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1834");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-3.01037632E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1835() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1835");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1709540.0f), 255726.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2907628.0f) + "'", float2 == (-2907628.0f));
    }

    @Test
    public void test1836() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1836");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.340502E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.983854900654278E8d + "'", double1 == 3.983854900654278E8d);
    }

    @Test
    public void test1837() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1837");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4920644.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.0917318082661387E7d + "'", double1 == 3.0917318082661387E7d);
    }

    @Test
    public void test1838() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1838");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 804707.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.8056576E7f + "'", float2 == 7.8056576E7f);
    }

    @Test
    public void test1839() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1839");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 1.1773644E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.1773644E7f) + "'", float2 == (-1.1773644E7f));
    }

    @Test
    public void test1840() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1840");
        double double1 = org.example.maths.Perimeter.perimeterCircle(14497.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 91087.33739818246d + "'", double1 == 91087.33739818246d);
    }

    @Test
    public void test1841() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1841");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.257892E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.903568532418744E7d + "'", double1 == 7.903568532418744E7d);
    }

    @Test
    public void test1842() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1842");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 3232000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6464000.0f + "'", float2 == 6464000.0f);
    }

    @Test
    public void test1843() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1843");
        double double1 = org.example.maths.Perimeter.perimeterCircle(84300.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 529672.5213952392d + "'", double1 == 529672.5213952392d);
    }

    @Test
    public void test1844() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1844");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1802148.0f, 269248.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4142792.0f + "'", float2 == 4142792.0f);
    }

    @Test
    public void test1845() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1845");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3890052.0f, 2.534976E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.8479624E7f + "'", float2 == 5.8479624E7f);
    }

    @Test
    public void test1846() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1846");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 505416.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.05416E7f + "'", float2 == 5.05416E7f);
    }

    @Test
    public void test1847() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1847");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 601188.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 601188.0f + "'", float2 == 601188.0f);
    }

    @Test
    public void test1848() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1848");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-8.2162426E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1849() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1849");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6678145.0f, 3768.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.3363826E7f + "'", float2 == 1.3363826E7f);
    }

    @Test
    public void test1850() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1850");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(961904.0f, 5.58815E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.13686808E8f + "'", float2 == 1.13686808E8f);
    }

    @Test
    public void test1851() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1851");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 480926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 480926.0f + "'", float2 == 480926.0f);
    }

    @Test
    public void test1852() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1852");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42938.0f, (-298865.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-511854.0f) + "'", float2 == (-511854.0f));
    }

    @Test
    public void test1853() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1853");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 304064.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 304064.0f + "'", float2 == 304064.0f);
    }

    @Test
    public void test1854() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1854");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(843.0f, 170720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 343126.0f + "'", float2 == 343126.0f);
    }

    @Test
    public void test1855() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1855");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.28386E7f, (-2.38225536E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.50773888E8f) + "'", float2 == (-4.50773888E8f));
    }

    @Test
    public void test1856() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1856");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(888126.0f, (-2056880.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2337508.0f) + "'", float2 == (-2337508.0f));
    }

    @Test
    public void test1857() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1857");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-48760.0f), (-3016.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-103552.0f) + "'", float2 == (-103552.0f));
    }

    @Test
    public void test1858() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1858");
        double double1 = org.example.maths.Perimeter.perimeterCircle(302342.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1899670.8121432904d + "'", double1 == 1899670.8121432904d);
    }

    @Test
    public void test1859() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1859");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.563036E8f), (-2055560.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.16718336E8f) + "'", float2 == (-3.16718336E8f));
    }

    @Test
    public void test1860() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1860");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 4738.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 246376.0f + "'", float2 == 246376.0f);
    }

    @Test
    public void test1861() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1861");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 5387.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 522539.0f + "'", float2 == 522539.0f);
    }

    @Test
    public void test1862() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1862");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(74345.0f, 4574925.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9298540.0f + "'", float2 == 9298540.0f);
    }

    @Test
    public void test1863() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1863");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-245450.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test1864() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1864");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-48844.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-306895.9031438797d) + "'", double1 == (-306895.9031438797d));
    }

    @Test
    public void test1865() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1865");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 2.56083424E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.5608343E9f + "'", float2 == 2.5608343E9f);
    }

    @Test
    public void test1866() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1866");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.02999824E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.275485511516842E9d) + "'", double1 == (-1.275485511516842E9d));
    }

    @Test
    public void test1867() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1867");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 2.8811578E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.8811578E7f + "'", float2 == 2.8811578E7f);
    }

    @Test
    public void test1868() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1868");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (-52861.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 52861.0f + "'", float2 == 52861.0f);
    }

    @Test
    public void test1869() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1869");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 956844.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 956844.0f + "'", float2 == 956844.0f);
    }

    @Test
    public void test1870() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1870");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 250710.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8774850.0f + "'", float2 == 8774850.0f);
    }

    @Test
    public void test1871() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1871");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.19638912E9f, 5.2161912E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.49710208E9f + "'", float2 == 2.49710208E9f);
    }

    @Test
    public void test1872() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1872");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7848400.0f, 153353.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.6003506E7f + "'", float2 == 1.6003506E7f);
    }

    @Test
    public void test1873() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1873");
        double double1 = org.example.maths.Perimeter.perimeterCircle(79497.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 499494.38236485556d + "'", double1 == 499494.38236485556d);
    }

    @Test
    public void test1874() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1874");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.397915E7f, 8.5997248E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.999528E8f + "'", float2 == 1.999528E8f);
    }

    @Test
    public void test1875() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1875");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.05040077E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.9166233286506927E10d + "'", double1 == 1.9166233286506927E10d);
    }

    @Test
    public void test1876() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1876");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-7.32816E7f), 38101.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.46486992E8f) + "'", float2 == (-1.46486992E8f));
    }

    @Test
    public void test1877() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1877");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.23490232E10f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.404230544011176E11d + "'", double1 == 1.404230544011176E11d);
    }

    @Test
    public void test1878() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1878");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1156012.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7263437.613323288d + "'", double1 == 7263437.613323288d);
    }

    @Test
    public void test1879() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1879");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 718758.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7187580.0f + "'", float2 == 7187580.0f);
    }

    @Test
    public void test1880() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1880");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1375069.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8639813.337158127d + "'", double1 == 8639813.337158127d);
    }

    @Test
    public void test1881() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1881");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.25930976E8f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.51861952E8f + "'", float2 == 2.51861952E8f);
    }

    @Test
    public void test1882() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1882");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(55172.0f, (-3.1197558E7f), 4496007.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1883() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1883");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1191277.0f, 820429.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4023412.0f + "'", float2 == 4023412.0f);
    }

    @Test
    public void test1884() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1884");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.86039616E8f), 5.2161912E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.67755392E8f) + "'", float2 == (-4.67755392E8f));
    }

    @Test
    public void test1885() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1885");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(363808.0f, 10531.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 748678.0f + "'", float2 == 748678.0f);
    }

    @Test
    public void test1886() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1886");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 2.9327112E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.93271117E9f + "'", float2 == 2.93271117E9f);
    }

    @Test
    public void test1887() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1887");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 106.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 10282.0f + "'", float2 == 10282.0f);
    }

    @Test
    public void test1888() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1888");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(171710.0f, 2068342.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4480104.0f + "'", float2 == 4480104.0f);
    }

    @Test
    public void test1889() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1889");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.60946E7f, 50392.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.2289984E7f + "'", float2 == 3.2289984E7f);
    }

    @Test
    public void test1890() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1890");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-3.1204544E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.09215908E10f) + "'", float2 == (-1.09215908E10f));
    }

    @Test
    public void test1891() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1891");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-48844.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-48844.0f) + "'", float2 == (-48844.0f));
    }

    @Test
    public void test1892() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1892");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3663.0f, 8734442.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.747621E7f + "'", float2 == 1.747621E7f);
    }

    @Test
    public void test1893() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1893");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-890014.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8900140.0f) + "'", float2 == (-8900140.0f));
    }

    @Test
    public void test1894() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1894");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-17000.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-170000.0f) + "'", float2 == (-170000.0f));
    }

    @Test
    public void test1895() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1895");
        double double1 = org.example.maths.Perimeter.perimeterCircle(278270.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1748421.9754288634d + "'", double1 == 1748421.9754288634d);
    }

    @Test
    public void test1896() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1896");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2140143.0f, 2273546.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8827378.0f + "'", float2 == 8827378.0f);
    }

    @Test
    public void test1897() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1897");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(0.0f, 230400.0f, (-4940.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1898() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1898");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-998191.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.1942112E7f) + "'", float2 == (-3.1942112E7f));
    }

    @Test
    public void test1899() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1899");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-100.0f), 1302250.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2604300.0f + "'", float2 == 2604300.0f);
    }

    @Test
    public void test1900() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1900");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 20283.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 709905.0f + "'", float2 == 709905.0f);
    }

    @Test
    public void test1901() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1901");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-48760.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-306368.1155780766d) + "'", double1 == (-306368.1155780766d));
    }

    @Test
    public void test1902() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1902");
        double double1 = org.example.maths.Perimeter.perimeterCircle(214310.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1346549.4431816572d + "'", double1 == 1346549.4431816572d);
    }

    @Test
    public void test1903() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1903");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(19697.0f, 2240.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 43874.0f + "'", float2 == 43874.0f);
    }

    @Test
    public void test1904() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1904");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4120771.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.589156780145173E7d) + "'", double1 == (-2.589156780145173E7d));
    }

    @Test
    public void test1905() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1905");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(291968.0f, 4.98962E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.00376336E8f + "'", float2 == 1.00376336E8f);
    }

    @Test
    public void test1906() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1906");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 421537.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-421537.0f) + "'", float2 == (-421537.0f));
    }

    @Test
    public void test1907() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1907");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 1267554.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.5912808E7f + "'", float2 == 6.5912808E7f);
    }

    @Test
    public void test1908() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1908");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.15327224E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-7.246223193546089E8d) + "'", double1 == (-7.246223193546089E8d));
    }

    @Test
    public void test1909() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1909");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(133235.0f, 1.24116152E10f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.48234967E10f + "'", float2 == 2.48234967E10f);
    }

    @Test
    public void test1910() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1910");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 13284.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 13284.0f + "'", float2 == 13284.0f);
    }

    @Test
    public void test1911() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1911");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1562499.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-9817470.759282796d) + "'", double1 == (-9817470.759282796d));
    }

    @Test
    public void test1912() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1912");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.4936684E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.1951365959037614E8d) + "'", double1 == (-2.1951365959037614E8d));
    }

    @Test
    public void test1913() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1913");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3433986.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.1576370380260397E7d + "'", double1 == 2.1576370380260397E7d);
    }

    @Test
    public void test1914() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1914");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 18124.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1812400.0f + "'", float2 == 1812400.0f);
    }

    @Test
    public void test1915() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1915");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(420168.0f, (-2.8570706E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.6301076E7f) + "'", float2 == (-5.6301076E7f));
    }

    @Test
    public void test1916() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1916");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-188545.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1184663.173742175d) + "'", double1 == (-1184663.173742175d));
    }

    @Test
    public void test1917() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1917");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 1.29495416E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.29495416E8f) + "'", float2 == (-1.29495416E8f));
    }

    @Test
    public void test1918() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1918");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 3.8782E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.76185395E9f + "'", float2 == 3.76185395E9f);
    }

    @Test
    public void test1919() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1919");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-483300.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3036663.4589598943d) + "'", double1 == (-3036663.4589598943d));
    }

    @Test
    public void test1920() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1920");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 538100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5381000.0f + "'", float2 == 5381000.0f);
    }

    @Test
    public void test1921() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1921");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.39406912E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.504237991915636E9d) + "'", double1 == (-1.504237991915636E9d));
    }

    @Test
    public void test1922() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1922");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 3.5852376E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.5852376E7f) + "'", float2 == (-3.5852376E7f));
    }

    @Test
    public void test1923() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1923");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.39305472E9f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-8.752820948801172E9d) + "'", double1 == (-8.752820948801172E9d));
    }

    @Test
    public void test1924() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1924");
        double double1 = org.example.maths.Perimeter.perimeterCircle(804707.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5056123.198984563d + "'", double1 == 5056123.198984563d);
    }

    @Test
    public void test1925() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1925");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.79390624E8f), 88576.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.58604096E8f) + "'", float2 == (-3.58604096E8f));
    }

    @Test
    public void test1926() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1926");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1394240.0f, 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2788612.0f + "'", float2 == 2788612.0f);
    }

    @Test
    public void test1927() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1927");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 994140.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.6431584E7f + "'", float2 == 9.6431584E7f);
    }

    @Test
    public void test1928() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1928");
        double double1 = org.example.maths.Perimeter.perimeterCircle(614364.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3860162.858060079d + "'", double1 == 3860162.858060079d);
    }

    @Test
    public void test1929() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1929");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(1.06085734E9f, 714381.0f, (-14890.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1930() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1930");
        double double1 = org.example.maths.Perimeter.perimeterCircle(22052.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 138556.80239392424d + "'", double1 == 138556.80239392424d);
    }

    @Test
    public void test1931() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1931");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3951500.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.4828006741320133E7d) + "'", double1 == (-2.4828006741320133E7d));
    }

    @Test
    public void test1932() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1932");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 142560.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4989600.0f + "'", float2 == 4989600.0f);
    }

    @Test
    public void test1933() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1933");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.35353568E8f, 359378.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.71425888E8f + "'", float2 == 4.71425888E8f);
    }

    @Test
    public void test1934() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1934");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-175744.0f), 2880875.0f, 2.562664E8f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1935() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1935");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-175744.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-175744.0f) + "'", float2 == (-175744.0f));
    }

    @Test
    public void test1936() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1936");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-998191.0f), 359343.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1277696.0f) + "'", float2 == (-1277696.0f));
    }

    @Test
    public void test1937() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1937");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5443242.0f), 3433986.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4018512.0f) + "'", float2 == (-4018512.0f));
    }

    @Test
    public void test1938() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1938");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 46.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4600.0f + "'", float2 == 4600.0f);
    }

    @Test
    public void test1939() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1939");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 1168736.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.0774272E7f + "'", float2 == 6.0774272E7f);
    }

    @Test
    public void test1940() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1940");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.7816138E7f, 3834540.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.3301356E7f + "'", float2 == 4.3301356E7f);
    }

    @Test
    public void test1941() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1941");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.3048544E7f), (-8222434.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.02541952E8f) + "'", float2 == (-1.02541952E8f));
    }

    @Test
    public void test1942() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1942");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 38608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1351280.0f + "'", float2 == 1351280.0f);
    }

    @Test
    public void test1943() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1943");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 6081372.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.081372E7f + "'", float2 == 6.081372E7f);
    }

    @Test
    public void test1944() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1944");
        double double1 = org.example.maths.Perimeter.perimeterCircle(269248.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1691735.0775874893d + "'", double1 == 1691735.0775874893d);
    }

    @Test
    public void test1945() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1945");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-245450.0f), 1.854835E7f, 4598.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1946() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1946");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(20768.0f, 6.081372E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.21668976E8f + "'", float2 == 1.21668976E8f);
    }

    @Test
    public void test1947() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1947");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.0163287E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.7801708116135605E10d + "'", double1 == 3.7801708116135605E10d);
    }

    @Test
    public void test1948() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1948");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(23520.0f, (-1.73796784E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.47546528E8f) + "'", float2 == (-3.47546528E8f));
    }

    @Test
    public void test1949() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1949");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-2.3765208E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.3765208E8f + "'", float2 == 2.3765208E8f);
    }

    @Test
    public void test1950() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1950");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 2.0070576E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.4225843E9f + "'", float2 == 6.4225843E9f);
    }

    @Test
    public void test1951() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1951");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-1.19684432E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.19684432E8f + "'", float2 == 1.19684432E8f);
    }

    @Test
    public void test1952() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1952");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(958511.0f, 200792.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2318606.0f + "'", float2 == 2318606.0f);
    }

    @Test
    public void test1953() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1953");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 4.4364392E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.436439E9f + "'", float2 == 4.436439E9f);
    }

    @Test
    public void test1954() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1954");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-420.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2638.9378290154264d) + "'", double1 == (-2638.9378290154264d));
    }

    @Test
    public void test1955() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1955");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.02393101E9f, 1.31074483E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.6693519E9f + "'", float2 == 4.6693519E9f);
    }

    @Test
    public void test1956() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1956");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(714381.0f, 2.49710208E9f, (-67128.0f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test1957() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1957");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 387425.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1958() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1958");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-7816300.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4.91112613165078E7d) + "'", double1 == (-4.91112613165078E7d));
    }

    @Test
    public void test1959() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1959");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 4.4041432E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.40414336E8f + "'", float2 == 4.40414336E8f);
    }

    @Test
    public void test1960() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1960");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7893746.0f, 606580.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7000652E7f + "'", float2 == 1.7000652E7f);
    }

    @Test
    public void test1961() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1961");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1352.0f, 2304000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4610704.0f + "'", float2 == 4610704.0f);
    }

    @Test
    public void test1962() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1962");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5.8661552E7f, (-1102.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.17320896E8f + "'", float2 == 1.17320896E8f);
    }

    @Test
    public void test1963() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1963");
        double double1 = org.example.maths.Perimeter.perimeterCircle(208192.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1308108.9154723324d + "'", double1 == 1308108.9154723324d);
    }

    @Test
    public void test1964() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1964");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 387820.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1965() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1965");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.27254784E8f, (-19805.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.54469952E8f + "'", float2 == 2.54469952E8f);
    }

    @Test
    public void test1966() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1966");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1.21668976E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1967() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1967");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 489806.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.7511184E7f + "'", float2 == 4.7511184E7f);
    }

    @Test
    public void test1968() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1968");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-4504064.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4504064.0f) + "'", float2 == (-4504064.0f));
    }

    @Test
    public void test1969() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1969");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-4.67499648E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.349993E8f) + "'", float2 == (-9.349993E8f));
    }

    @Test
    public void test1970() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1970");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.3641006E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4854082154614446E8d) + "'", double1 == (-1.4854082154614446E8d));
    }

    @Test
    public void test1971() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1971");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2418936.0f, 1780664.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8399200.0f + "'", float2 == 8399200.0f);
    }

    @Test
    public void test1972() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1972");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3143410.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.9750627526441384E7d + "'", double1 == 1.9750627526441384E7d);
    }

    @Test
    public void test1973() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1973");
        double double1 = org.example.maths.Perimeter.perimeterCircle(341530.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2145896.277961044d + "'", double1 == 2145896.277961044d);
    }

    @Test
    public void test1974() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1974");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1975() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1975");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.09154272E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.9424735794822013E9d + "'", double1 == 1.9424735794822013E9d);
    }

    @Test
    public void test1976() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1976");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, (float) (short) 10);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10.0f) + "'", float2 == (-10.0f));
    }

    @Test
    public void test1977() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1977");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(154808.0f, 3032203.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6374022.0f + "'", float2 == 6374022.0f);
    }

    @Test
    public void test1978() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1978");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 8390271.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8390271.0f) + "'", float2 == (-8390271.0f));
    }

    @Test
    public void test1979() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1979");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1073160.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6742863.144252845d + "'", double1 == 6742863.144252845d);
    }

    @Test
    public void test1980() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1980");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-1.86445E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.80851648E9f) + "'", float2 == (-1.80851648E9f));
    }

    @Test
    public void test1981() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1981");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.9537016E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.740821041645159E8d + "'", double1 == 3.740821041645159E8d);
    }

    @Test
    public void test1982() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1982");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2780.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 17467.25515395925d + "'", double1 == 17467.25515395925d);
    }

    @Test
    public void test1983() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1983");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(125954.0f, 506172.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1264252.0f + "'", float2 == 1264252.0f);
    }

    @Test
    public void test1984() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1984");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.5912808E7f, (-1.80851648E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.4852073E9f) + "'", float2 == (-3.4852073E9f));
    }

    @Test
    public void test1985() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1985");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(85664.0f, (-225640.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-279952.0f) + "'", float2 == (-279952.0f));
    }

    @Test
    public void test1986() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1986");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 1217.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1217.0f + "'", float2 == 1217.0f);
    }

    @Test
    public void test1987() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1987");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2860396.0f, 1718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5724228.0f + "'", float2 == 5724228.0f);
    }

    @Test
    public void test1988() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1988");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 5290.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5290.0f) + "'", float2 == (-5290.0f));
    }

    @Test
    public void test1989() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1989");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(538100.0f, 3.3479134E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.8034464E7f + "'", float2 == 6.8034464E7f);
    }

    @Test
    public void test1990() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1990");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 84915.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1991() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1991");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(16304.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 32608.0f + "'", float2 == 32608.0f);
    }

    @Test
    public void test1992() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1992");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-229267.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-458534.0f) + "'", float2 == (-458534.0f));
    }

    @Test
    public void test1993() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1993");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.78664016E8f, 88924.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.57505888E8f + "'", float2 == 3.57505888E8f);
    }

    @Test
    public void test1994() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1994");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9700.0f, 429361.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 878122.0f + "'", float2 == 878122.0f);
    }

    @Test
    public void test1995() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1995");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1603692.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1996() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1996");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) (short) 1, 2673484.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5346970.0f + "'", float2 == 5346970.0f);
    }

    @Test
    public void test1997() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1997");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', (-115.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4025.0f) + "'", float2 == (-4025.0f));
    }

    @Test
    public void test1998() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1998");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 2.394591E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test1999() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test1999");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(46.0f, 20908.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 41908.0f + "'", float2 == 41908.0f);
    }

    @Test
    public void test2000() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2000");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 972041.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1944082.0f + "'", float2 == 1944082.0f);
    }

    @Test
    public void test2001() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2001");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.48564608E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.334589621524948E8d + "'", double1 == 9.334589621524948E8d);
    }

    @Test
    public void test2002() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2002");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(784840.0f, (-1277696.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-985712.0f) + "'", float2 == (-985712.0f));
    }

    @Test
    public void test2003() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2003");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5734115.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.6028507117678076E7d + "'", double1 == 3.6028507117678076E7d);
    }

    @Test
    public void test2004() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2004");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.08518944E8f), 5253662.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.0653056E8f) + "'", float2 == (-8.0653056E8f));
    }

    @Test
    public void test2005() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2005");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-8390271.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.6780542E7f) + "'", float2 == (-1.6780542E7f));
    }

    @Test
    public void test2006() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2006");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7765434.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.87916608126728E7d + "'", double1 == 4.87916608126728E7d);
    }

    @Test
    public void test2007() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2007");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 48672.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2008() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2008");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-5.7913984E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.7913986E11f) + "'", float2 == (-5.7913986E11f));
    }

    @Test
    public void test2009() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2009");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 6.0774272E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.0774272E7f + "'", float2 == 6.0774272E7f);
    }

    @Test
    public void test2010() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2010");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7772.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 48832.91620739974d + "'", double1 == 48832.91620739974d);
    }

    @Test
    public void test2011() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2011");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-72206.0f), 188545.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 232678.0f + "'", float2 == 232678.0f);
    }

    @Test
    public void test2012() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2012");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 2.75871936E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.75871936E8f + "'", float2 == 2.75871936E8f);
    }

    @Test
    public void test2013() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2013");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5443242.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3.4200898157822825E7d) + "'", double1 == (-3.4200898157822825E7d));
    }

    @Test
    public void test2014() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2014");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 1.94501408E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.88666368E10f + "'", float2 == 1.88666368E10f);
    }

    @Test
    public void test2015() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2015");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 3834540.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.83454E7f + "'", float2 == 3.83454E7f);
    }

    @Test
    public void test2016() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2016");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-38515.0f), 5.5227064E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.10377096E8f + "'", float2 == 1.10377096E8f);
    }

    @Test
    public void test2017() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2017");
        double double1 = org.example.maths.Perimeter.perimeterCircle(887222.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5574580.234606487d + "'", double1 == 5574580.234606487d);
    }

    @Test
    public void test2018() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2018");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.969748E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.750903292116472E8d + "'", double1 == 3.750903292116472E8d);
    }

    @Test
    public void test2019() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2019");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 2646.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 264600.0f + "'", float2 == 264600.0f);
    }

    @Test
    public void test2020() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2020");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 52861.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 52861.0f + "'", float2 == 52861.0f);
    }

    @Test
    public void test2021() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2021");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-749040.0f), (-3.58604096E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.187063E8f) + "'", float2 == (-7.187063E8f));
    }

    @Test
    public void test2022() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2022");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9459089.0f, 1812400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.2542978E7f + "'", float2 == 2.2542978E7f);
    }

    @Test
    public void test2023() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2023");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 85598.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2024() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2024");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 42980.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-42980.0f) + "'", float2 == (-42980.0f));
    }

    @Test
    public void test2025() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2025");
        double double1 = org.example.maths.Perimeter.perimeterCircle(42624.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 267814.4905332227d + "'", double1 == 267814.4905332227d);
    }

    @Test
    public void test2026() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2026");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2304000.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4476458947741767E7d) + "'", double1 == (-1.4476458947741767E7d));
    }

    @Test
    public void test2027() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2027");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5346970.0f, 1779912.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4253764E7f + "'", float2 == 1.4253764E7f);
    }

    @Test
    public void test2028() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2028");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-3.16718336E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test2029() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2029");
        double double1 = org.example.maths.Perimeter.perimeterCircle(211186.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1326920.772282028d + "'", double1 == 1326920.772282028d);
    }

    @Test
    public void test2030() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2030");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 956844.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.348954E7f + "'", float2 == 3.348954E7f);
    }

    @Test
    public void test2031() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2031");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 661720.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-661720.0f) + "'", float2 == (-661720.0f));
    }

    @Test
    public void test2032() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2032");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-22504.0f), 310038.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 575068.0f + "'", float2 == 575068.0f);
    }

    @Test
    public void test2033() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2033");
        double double1 = org.example.maths.Perimeter.perimeterCircle(12170.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 76466.36518837557d + "'", double1 == 76466.36518837557d);
    }

    @Test
    public void test2034() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2034");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7.3472568E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.61641759738353E8d + "'", double1 == 4.61641759738353E8d);
    }

    @Test
    public void test2035() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2035");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4.71425888E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.9620562129056892E9d + "'", double1 == 2.9620562129056892E9d);
    }

    @Test
    public void test2036() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2036");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1865500.0f, (-4560.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3721880.0f + "'", float2 == 3721880.0f);
    }

    @Test
    public void test2037() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2037");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1813932.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.139727089062288E7d + "'", double1 == 1.139727089062288E7d);
    }

    @Test
    public void test2038() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2038");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.49037776E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.364319643779224E8d + "'", double1 == 9.364319643779224E8d);
    }

    @Test
    public void test2039() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2039");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 252.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2520.0f + "'", float2 == 2520.0f);
    }

    @Test
    public void test2040() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2040");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1425600.0f, (-30.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2851140.0f + "'", float2 == 2851140.0f);
    }

    @Test
    public void test2041() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2041");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-7772656.0f), 777062.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.3991188E7f) + "'", float2 == (-1.3991188E7f));
    }

    @Test
    public void test2042() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2042");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-31975.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-200904.85019706728d) + "'", double1 == (-200904.85019706728d));
    }

    @Test
    public void test2043() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2043");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 1394240.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2044() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2044");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-105930.0f), 1215672.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2219484.0f + "'", float2 == 2219484.0f);
    }

    @Test
    public void test2045() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2045");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(579910.0f, 1.09375704E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.19911232E8f + "'", float2 == 2.19911232E8f);
    }

    @Test
    public void test2046() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2046");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.1836307E7f, 1944082.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.7560778E7f + "'", float2 == 2.7560778E7f);
    }

    @Test
    public void test2047() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2047");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.05183631E10f, 1.50549453E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.40477143E10f + "'", float2 == 2.40477143E10f);
    }

    @Test
    public void test2048() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2048");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-8.9986968E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.9986968E7f) + "'", float2 == (-8.9986968E7f));
    }

    @Test
    public void test2049() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2049");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 9382464.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9382464.0f + "'", float2 == 9382464.0f);
    }

    @Test
    public void test2050() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2050");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 1.87794176E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.82160343E10f + "'", float2 == 1.82160343E10f);
    }

    @Test
    public void test2051() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2051");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.50440624E8f), 16304.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.0084864E8f) + "'", float2 == (-3.0084864E8f));
    }

    @Test
    public void test2052() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2052");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-71934.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-719340.0f) + "'", float2 == (-719340.0f));
    }

    @Test
    public void test2053() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2053");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.74262592E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.0949241576454308E9d) + "'", double1 == (-1.0949241576454308E9d));
    }

    @Test
    public void test2054() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2054");
        double double1 = org.example.maths.Perimeter.perimeterCircle(510.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3204.424506661589d + "'", double1 == 3204.424506661589d);
    }

    @Test
    public void test2055() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2055");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(126602.0f, (-1.52756E7f), 513244.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2056() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2056");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 9180052.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9180052.0f) + "'", float2 == (-9180052.0f));
    }

    @Test
    public void test2057() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2057");
        double double1 = org.example.maths.Perimeter.perimeterCircle(239224.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1503088.7219247294d + "'", double1 == 1503088.7219247294d);
    }

    @Test
    public void test2058() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2058");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2301926.0f, 6.3020296E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.30644448E8f + "'", float2 == 1.30644448E8f);
    }

    @Test
    public void test2059() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2059");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2235184.0f), (-340.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4471048.0f) + "'", float2 == (-4471048.0f));
    }

    @Test
    public void test2060() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2060");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2992220.0f), 1.4663296E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.3342152E7f + "'", float2 == 2.3342152E7f);
    }

    @Test
    public void test2061() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2061");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1980000.0f), 3032203.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2104406.0f + "'", float2 == 2104406.0f);
    }

    @Test
    public void test2062() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2062");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 5183686.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.65877952E8f + "'", float2 == 1.65877952E8f);
    }

    @Test
    public void test2063() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2063");
        double double1 = org.example.maths.Perimeter.perimeterCircle(69.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 433.53978619539146d + "'", double1 == 433.53978619539146d);
    }

    @Test
    public void test2064() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2064");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(11700.0f, 5063658.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.0150716E7f + "'", float2 == 1.0150716E7f);
    }

    @Test
    public void test2065() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2065");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6840.0f, 4661946.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9337572.0f + "'", float2 == 9337572.0f);
    }

    @Test
    public void test2066() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2066");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 1.854835E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.85483494E9f + "'", float2 == 1.85483494E9f);
    }

    @Test
    public void test2067() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2067");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-5917282.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.917282E7f) + "'", float2 == (-5.917282E7f));
    }

    @Test
    public void test2068() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2068");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1264480.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-7944962.157222443d) + "'", double1 == (-7944962.157222443d));
    }

    @Test
    public void test2069() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2069");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 2136520.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.13652E8f + "'", float2 == 2.13652E8f);
    }

    @Test
    public void test2070() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2070");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-4425034.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.3010176E8f) + "'", float2 == (-2.3010176E8f));
    }

    @Test
    public void test2071() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2071");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-1.27959576E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test2072() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2072");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2860396.0f), 40.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5720712.0f) + "'", float2 == (-5720712.0f));
    }

    @Test
    public void test2073() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2073");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(12122.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 24244.0f + "'", float2 == 24244.0f);
    }

    @Test
    public void test2074() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2074");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-266030.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1671515.7872689853d) + "'", double1 == (-1671515.7872689853d));
    }

    @Test
    public void test2075() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2075");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.78664016E8f, 1668285.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.60664608E8f + "'", float2 == 3.60664608E8f);
    }

    @Test
    public void test2076() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2076");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-127940.0f), (-11254.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-278388.0f) + "'", float2 == (-278388.0f));
    }

    @Test
    public void test2077() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2077");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4672052.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.9355368480779E7d + "'", double1 == 2.9355368480779E7d);
    }

    @Test
    public void test2078() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2078");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 1073160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.07316E8f + "'", float2 == 1.07316E8f);
    }

    @Test
    public void test2079() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2079");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-4.7438912E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.51804518E10f) + "'", float2 == (-1.51804518E10f));
    }

    @Test
    public void test2080() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2080");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1.0015576E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.50545152E8f + "'", float2 == 3.50545152E8f);
    }

    @Test
    public void test2081() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2081");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5867026.0f, 599135.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2932322E7f + "'", float2 == 1.2932322E7f);
    }

    @Test
    public void test2082() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2082");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', (-3016.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-156832.0f) + "'", float2 == (-156832.0f));
    }

    @Test
    public void test2083() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2083");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 915698.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1831396.0f + "'", float2 == 1831396.0f);
    }

    @Test
    public void test2084() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2084");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-7.187063E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-4.515764889470145E9d) + "'", double1 == (-4.515764889470145E9d));
    }

    @Test
    public void test2085() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2085");
        double double1 = org.example.maths.Perimeter.perimeterCircle(80911.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 508378.8063892075d + "'", double1 == 508378.8063892075d);
    }

    @Test
    public void test2086() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2086");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.73278752E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.0887425086128154E9d) + "'", double1 == (-1.0887425086128154E9d));
    }

    @Test
    public void test2087() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2087");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), (-1856.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1856.0f + "'", float2 == 1856.0f);
    }

    @Test
    public void test2088() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2088");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.47339504E8f), 13012.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.94652992E8f) + "'", float2 == (-2.94652992E8f));
    }

    @Test
    public void test2089() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2089");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1425600.0f, 42889.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2936978.0f + "'", float2 == 2936978.0f);
    }

    @Test
    public void test2090() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2090");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1858334.0f), (-3.9933E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.3582672E7f) + "'", float2 == (-8.3582672E7f));
    }

    @Test
    public void test2091() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2091");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1944082.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.2215027458352305E7d + "'", double1 == 1.2215027458352305E7d);
    }

    @Test
    public void test2092() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2092");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.754287E7f, (-39416.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.5006908E7f + "'", float2 == 3.5006908E7f);
    }

    @Test
    public void test2093() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2093");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1128840.0f, 2067892.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6393464.0f + "'", float2 == 6393464.0f);
    }

    @Test
    public void test2094() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2094");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2068342.0f, 230228.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4597140.0f + "'", float2 == 4597140.0f);
    }

    @Test
    public void test2095() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2095");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1426970.0f, 297144.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3448228.0f + "'", float2 == 3448228.0f);
    }

    @Test
    public void test2096() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2096");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-114261.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-717923.0363836467d) + "'", double1 == (-717923.0363836467d));
    }

    @Test
    public void test2097() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2097");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2301926.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4463427621414676E7d) + "'", double1 == (-1.4463427621414676E7d));
    }

    @Test
    public void test2098() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2098");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(180543.0f, 1.4253764E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.8868614E7f + "'", float2 == 2.8868614E7f);
    }

    @Test
    public void test2099() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2099");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8734442.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.488011764081228E7d + "'", double1 == 5.488011764081228E7d);
    }

    @Test
    public void test2100() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2100");
        double double1 = org.example.maths.Perimeter.perimeterCircle(42932.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 269749.711607834d + "'", double1 == 269749.711607834d);
    }

    @Test
    public void test2101() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2101");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 28420.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 994700.0f + "'", float2 == 994700.0f);
    }

    @Test
    public void test2102() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2102");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.8008226E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.7598087408336526E8d + "'", double1 == 1.7598087408336526E8d);
    }

    @Test
    public void test2103() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2103");
        double double1 = org.example.maths.Perimeter.perimeterCircle(382037.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2400409.2651989674d + "'", double1 == 2400409.2651989674d);
    }

    @Test
    public void test2104() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2104");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1.397915E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.397915E7f + "'", float2 == 1.397915E7f);
    }

    @Test
    public void test2105() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2105");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.5687608E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.1272741344937223E8d + "'", double1 == 4.1272741344937223E8d);
    }

    @Test
    public void test2106() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2106");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 520.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 52000.0f + "'", float2 == 52000.0f);
    }

    @Test
    public void test2107() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2107");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.2887808E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.951357512263308E8d + "'", double1 == 3.951357512263308E8d);
    }

    @Test
    public void test2108() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2108");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-19300.0f), 2623704.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5208808.0f + "'", float2 == 5208808.0f);
    }

    @Test
    public void test2109() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2109");
        double double1 = org.example.maths.Perimeter.perimeterCircle(878122.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5517403.248311153d + "'", double1 == 5517403.248311153d);
    }

    @Test
    public void test2110() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2110");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5.2737056E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.05474112E8f + "'", float2 == 1.05474112E8f);
    }

    @Test
    public void test2111() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2111");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3016.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-18950.08688645363d) + "'", double1 == (-18950.08688645363d));
    }

    @Test
    public void test2112() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2112");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 8566100.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.45437184E8f + "'", float2 == 4.45437184E8f);
    }

    @Test
    public void test2113() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2113");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.14713128E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-7.207638403902112E8d) + "'", double1 == (-7.207638403902112E8d));
    }

    @Test
    public void test2114() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2114");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.5337846E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.476979394102022E10d + "'", double1 == 3.476979394102022E10d);
    }

    @Test
    public void test2115() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2115");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 79130.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 79130.0f + "'", float2 == 79130.0f);
    }

    @Test
    public void test2116() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2116");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-1.02541952E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.02541952E8f + "'", float2 == 1.02541952E8f);
    }

    @Test
    public void test2117() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2117");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.7265862E7f, 1.60945997E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.27345178E9f + "'", float2 == 3.27345178E9f);
    }

    @Test
    public void test2118() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2118");
        double double1 = org.example.maths.Perimeter.perimeterCircle(303430.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1906506.9177575018d + "'", double1 == 1906506.9177575018d);
    }

    @Test
    public void test2119() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2119");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.16718336E8f), 24244.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.3338816E8f) + "'", float2 == (-6.3338816E8f));
    }

    @Test
    public void test2120() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2120");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 3879620.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.87961984E8f + "'", float2 == 3.87961984E8f);
    }

    @Test
    public void test2121() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2121");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.4995036E7f, 9.567648E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.2134304E8f + "'", float2 == 2.2134304E8f);
    }

    @Test
    public void test2122() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2122");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-399330.0f), 9.567648E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.91273088E9f + "'", float2 == 1.91273088E9f);
    }

    @Test
    public void test2123() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2123");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, (-42746.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test2124() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2124");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 1643568.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2125() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2125");
        double double1 = org.example.maths.Perimeter.perimeterCircle(172.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1080.7078728348888d + "'", double1 == 1080.7078728348888d);
    }

    @Test
    public void test2126() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2126");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-14402.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-460864.0f) + "'", float2 == (-460864.0f));
    }

    @Test
    public void test2127() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2127");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.5859664E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.2531291396519675E9d) + "'", double1 == (-2.2531291396519675E9d));
    }

    @Test
    public void test2128() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2128");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.09972864E8f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.1994573E8f) + "'", float2 == (-8.1994573E8f));
    }

    @Test
    public void test2129() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2129");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.29495416E8f), 5.6233988E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.46522848E8f) + "'", float2 == (-1.46522848E8f));
    }

    @Test
    public void test2130() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2130");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.05556E8f), (-7.9877248E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.708665E8f) + "'", float2 == (-5.708665E8f));
    }

    @Test
    public void test2131() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2131");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-99506.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-99506.0f) + "'", float2 == (-99506.0f));
    }

    @Test
    public void test2132() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2132");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-166025.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1043165.8406244908d) + "'", double1 == (-1043165.8406244908d));
    }

    @Test
    public void test2133() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2133");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2922098.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8360083219738856E7d + "'", double1 == 1.8360083219738856E7d);
    }

    @Test
    public void test2134() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2134");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(196059.0f, 7.4518976E7f, 244850.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2135() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2135");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 26024.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 832768.0f + "'", float2 == 832768.0f);
    }

    @Test
    public void test2136() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2136");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(367783.0f, 2418936.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5573438.0f + "'", float2 == 5573438.0f);
    }

    @Test
    public void test2137() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2137");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1279415.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8038801.52978517d + "'", double1 == 8038801.52978517d);
    }

    @Test
    public void test2138() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2138");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.1286522E8f), 2.23490232E10f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.3072315E10f + "'", float2 == 4.3072315E10f);
    }

    @Test
    public void test2139() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2139");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.2943896E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.9548816252383995E8d + "'", double1 == 3.9548816252383995E8d);
    }

    @Test
    public void test2140() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2140");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5.7913986E11f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3.638843075037935E12d) + "'", double1 == (-3.638843075037935E12d));
    }

    @Test
    public void test2141() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2141");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 3381082.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2142() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2142");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-2.55742912E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.55742912E8f) + "'", float2 == (-2.55742912E8f));
    }

    @Test
    public void test2143() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2143");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-52.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-520.0f) + "'", float2 == (-520.0f));
    }

    @Test
    public void test2144() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2144");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-103552.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-650636.4049290605d) + "'", double1 == (-650636.4049290605d));
    }

    @Test
    public void test2145() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2145");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 842200.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2146() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2146");
        double double1 = org.example.maths.Perimeter.perimeterCircle(269114.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1690893.1307563272d + "'", double1 == 1690893.1307563272d);
    }

    @Test
    public void test2147() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2147");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-971228.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9712280.0f) + "'", float2 == (-9712280.0f));
    }

    @Test
    public void test2148() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2148");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-177152.0f), 1.78567264E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.56780224E8f + "'", float2 == 3.56780224E8f);
    }

    @Test
    public void test2149() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2149");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-68.0f), 4675.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9214.0f + "'", float2 == 9214.0f);
    }

    @Test
    public void test2150() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2150");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-100.0f), 6.3459155E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.26918285E9f + "'", float2 == 1.26918285E9f);
    }

    @Test
    public void test2151() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2151");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, (-4.67499648E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.67499648E8f) + "'", float2 == (-4.67499648E8f));
    }

    @Test
    public void test2152() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2152");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1.6125251E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.6438381E8f + "'", float2 == 5.6438381E8f);
    }

    @Test
    public void test2153() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2153");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2118.0f), 1350.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1536.0f) + "'", float2 == (-1536.0f));
    }

    @Test
    public void test2154() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2154");
        double double1 = org.example.maths.Perimeter.perimeterCircle(486110.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3054319.2096730685d + "'", double1 == 3054319.2096730685d);
    }

    @Test
    public void test2155() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2155");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 2.924499E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.924499E7f + "'", float2 == 2.924499E7f);
    }

    @Test
    public void test2156() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2156");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4025.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-25289.820861397835d) + "'", double1 == (-25289.820861397835d));
    }

    @Test
    public void test2157() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2157");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(694284.0f, 4875614.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1139796E7f + "'", float2 == 1.1139796E7f);
    }

    @Test
    public void test2158() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2158");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(231280.0f, (-1102.0f), (-8.1994573E8f), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2159() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2159");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1031680.0f, (-852.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2061656.0f + "'", float2 == 2061656.0f);
    }

    @Test
    public void test2160() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2160");
        double double1 = org.example.maths.Perimeter.perimeterCircle(133455.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 838522.4951696517d + "'", double1 == 838522.4951696517d);
    }

    @Test
    public void test2161() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2161");
        double double1 = org.example.maths.Perimeter.perimeterCircle(84915.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 533536.6803591546d + "'", double1 == 533536.6803591546d);
    }

    @Test
    public void test2162() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2162");
        double double1 = org.example.maths.Perimeter.perimeterCircle(267534.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1680965.6979709833d + "'", double1 == 1680965.6979709833d);
    }

    @Test
    public void test2163() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2163");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 8374312.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.374312E7f + "'", float2 == 8.374312E7f);
    }

    @Test
    public void test2164() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2164");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.5716136E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6157924787263203E8d + "'", double1 == 1.6157924787263203E8d);
    }

    @Test
    public void test2165() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2165");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4738.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 29769.731985416878d + "'", double1 == 29769.731985416878d);
    }

    @Test
    public void test2166() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2166");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6402.0f + "'", float2 == 6402.0f);
    }

    @Test
    public void test2167() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2167");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.492674E10f, 1.00348768E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.30054177E11f + "'", float2 == 1.30054177E11f);
    }

    @Test
    public void test2168() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2168");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.2542525E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.880700879493263E7d + "'", double1 == 7.880700879493263E7d);
    }

    @Test
    public void test2169() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2169");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 4.74256992E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.74256992E8f + "'", float2 == 4.74256992E8f);
    }

    @Test
    public void test2170() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2170");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-4200.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test2171() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2171");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.854835E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1654272019242448E8d + "'", double1 == 1.1654272019242448E8d);
    }

    @Test
    public void test2172() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2172");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(195344.0f, 2331240.0f, 2.7560778E7f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2173() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2173");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.2161912E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.2774295907279456E8d + "'", double1 == 3.2774295907279456E8d);
    }

    @Test
    public void test2174() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2174");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2871040.0f, 5332460.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.6407E7f + "'", float2 == 1.6407E7f);
    }

    @Test
    public void test2175() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2175");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 5.6233988E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2176() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2176");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 2000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 200000.0f + "'", float2 == 200000.0f);
    }

    @Test
    public void test2177() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2177");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-3.01170688E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.01170688E8f) + "'", float2 == (-3.01170688E8f));
    }

    @Test
    public void test2178() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2178");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2734476.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.7181219426035207E7d + "'", double1 == 1.7181219426035207E7d);
    }

    @Test
    public void test2179() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2179");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 138775.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2180() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2180");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1827078.0f), (-140752.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3935660.0f) + "'", float2 == (-3935660.0f));
    }

    @Test
    public void test2181() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2181");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1416402.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8899516.23545978d + "'", double1 == 8899516.23545978d);
    }

    @Test
    public void test2182() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2182");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 2202.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 220200.0f + "'", float2 == 220200.0f);
    }

    @Test
    public void test2183() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2183");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(28.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 56.0f + "'", float2 == 56.0f);
    }

    @Test
    public void test2184() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2184");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(505225.0f, 738.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1011926.0f + "'", float2 == 1011926.0f);
    }

    @Test
    public void test2185() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2185");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 66.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 66.0f + "'", float2 == 66.0f);
    }

    @Test
    public void test2186() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2186");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 162224.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5191168.0f + "'", float2 == 5191168.0f);
    }

    @Test
    public void test2187() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2187");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 2677470.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2677470.0f + "'", float2 == 2677470.0f);
    }

    @Test
    public void test2188() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2188");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(154588.0f, (-8.9986968E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.79664768E8f) + "'", float2 == (-1.79664768E8f));
    }

    @Test
    public void test2189() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2189");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(77532.0f, 43712.0f, 1.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2190() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2190");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 8411684.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2191() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2191");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(305366.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 610732.0f + "'", float2 == 610732.0f);
    }

    @Test
    public void test2192() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2192");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-7816300.0f), 599135.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.443433E7f) + "'", float2 == (-1.443433E7f));
    }

    @Test
    public void test2193() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2193");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.3293266E7f, 77532.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.6741596E7f + "'", float2 == 4.6741596E7f);
    }

    @Test
    public void test2194() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2194");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(0.0f, (-7854901.0f), 3.6917016E7f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2195() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2195");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1.5331494E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.53314944E8f + "'", float2 == 1.53314944E8f);
    }

    @Test
    public void test2196() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2196");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1.7630308E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2197() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2197");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(809110.0f, 1.4411372E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.0440964E7f + "'", float2 == 3.0440964E7f);
    }

    @Test
    public void test2198() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2198");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(175744.0f, (-42097.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 267294.0f + "'", float2 == 267294.0f);
    }

    @Test
    public void test2199() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2199");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon((-1660609.0f), 85980.0f, (float) (-1L), floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2200() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2200");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1846426.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1601436713994374E7d + "'", double1 == 1.1601436713994374E7d);
    }

    @Test
    public void test2201() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2201");
        double double1 = org.example.maths.Perimeter.perimeterCircle(18124.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 113876.45050732282d + "'", double1 == 113876.45050732282d);
    }

    @Test
    public void test2202() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2202");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 220.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 22000.0f + "'", float2 == 22000.0f);
    }

    @Test
    public void test2203() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2203");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 6550370.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.5503699E8f + "'", float2 == 6.5503699E8f);
    }

    @Test
    public void test2204() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2204");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1350.0f, 170.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3040.0f + "'", float2 == 3040.0f);
    }

    @Test
    public void test2205() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2205");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.84512128E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.4159609530819564E9d) + "'", double1 == (-2.4159609530819564E9d));
    }

    @Test
    public void test2206() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2206");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-225640.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.2564E7f) + "'", float2 == (-2.2564E7f));
    }

    @Test
    public void test2207() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2207");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-266030.0f), 2.7347274E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.4162488E7f + "'", float2 == 5.4162488E7f);
    }

    @Test
    public void test2208() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2208");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 2758160.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.75816E8f + "'", float2 == 2.75816E8f);
    }

    @Test
    public void test2209() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2209");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(73068.0f, 800846.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1747828.0f + "'", float2 == 1747828.0f);
    }

    @Test
    public void test2210() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2210");
        double double1 = org.example.maths.Perimeter.perimeterCircle(131880.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 828626.4783108438d + "'", double1 == 828626.4783108438d);
    }

    @Test
    public void test2211() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2211");
        double double1 = org.example.maths.Perimeter.perimeterCircle(709905.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4460464.665493324d + "'", double1 == 4460464.665493324d);
    }

    @Test
    public void test2212() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2212");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', (-11900.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-380800.0f) + "'", float2 == (-380800.0f));
    }

    @Test
    public void test2213() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2213");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-604940.0f), 1.05183632E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.09157376E8f + "'", float2 == 2.09157376E8f);
    }

    @Test
    public void test2214() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2214");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.310094E7f, (-127940.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.5946E7f + "'", float2 == 2.5946E7f);
    }

    @Test
    public void test2215() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2215");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(42192.0f, 5.45226E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.09129584E8f + "'", float2 == 1.09129584E8f);
    }

    @Test
    public void test2216() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2216");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-35188.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-221092.7245890353d) + "'", double1 == (-221092.7245890353d));
    }

    @Test
    public void test2217() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2217");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(907600.0f, 5.11965376E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.02574592E9f + "'", float2 == 1.02574592E9f);
    }

    @Test
    public void test2218() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2218");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.6579384E9f, (-2005900.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.3118648E9f + "'", float2 == 9.3118648E9f);
    }

    @Test
    public void test2219() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2219");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.4384446E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.038013975911817E7d + "'", double1 == 9.038013975911817E7d);
    }

    @Test
    public void test2220() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2220");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.82160343E10f, 2.4417378E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.6480905E10f + "'", float2 == 3.6480905E10f);
    }

    @Test
    public void test2221() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2221");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(424.0f, 462384.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 925616.0f + "'", float2 == 925616.0f);
    }

    @Test
    public void test2222() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2222");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6506.0f, 10.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 13032.0f + "'", float2 == 13032.0f);
    }

    @Test
    public void test2223() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2223");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-75434.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-150868.0f) + "'", float2 == (-150868.0f));
    }

    @Test
    public void test2224() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2224");
        double double1 = org.example.maths.Perimeter.perimeterCircle(175744.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1104232.1186249692d + "'", double1 == 1104232.1186249692d);
    }

    @Test
    public void test2225() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2225");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4371400.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.7466316251804844E7d + "'", double1 == 2.7466316251804844E7d);
    }

    @Test
    public void test2226() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2226");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3986224.0f, 92842.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8158132.0f + "'", float2 == 8158132.0f);
    }

    @Test
    public void test2227() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2227");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1.4342432E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4342432E9f + "'", float2 == 1.4342432E9f);
    }

    @Test
    public void test2228() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2228");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 1.8621926E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.86219264E9f + "'", float2 == 1.86219264E9f);
    }

    @Test
    public void test2229() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2229");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2235184.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.4044075267642897E7d) + "'", double1 == (-1.4044075267642897E7d));
    }

    @Test
    public void test2230() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2230");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 5.2161912E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.21619136E8f + "'", float2 == 5.21619136E8f);
    }

    @Test
    public void test2231() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2231");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-5270.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-52700.0f) + "'", float2 == (-52700.0f));
    }

    @Test
    public void test2232() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2232");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.2932322E7f, (-1.50671008E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.75477376E8f) + "'", float2 == (-2.75477376E8f));
    }

    @Test
    public void test2233() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2233");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(106.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 212.0f + "'", float2 == 212.0f);
    }

    @Test
    public void test2234() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2234");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 234293.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-234293.0f) + "'", float2 == (-234293.0f));
    }

    @Test
    public void test2235() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2235");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 10, (-4.50773888E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.0154778E8f) + "'", float2 == (-9.0154778E8f));
    }

    @Test
    public void test2236() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2236");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, (-428661.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test2237() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2237");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 212259.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2238() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2238");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 367783.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-367783.0f) + "'", float2 == (-367783.0f));
    }

    @Test
    public void test2239() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2239");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 37680.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1959360.0f + "'", float2 == 1959360.0f);
    }

    @Test
    public void test2240() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2240");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.433237E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.413803483855901E10d + "'", double1 == 3.413803483855901E10d);
    }

    @Test
    public void test2241() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2241");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.5318344E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.624799395112257E7d + "'", double1 == 9.624799395112257E7d);
    }

    @Test
    public void test2242() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2242");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-14402.0f), 21680.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 14556.0f + "'", float2 == 14556.0f);
    }

    @Test
    public void test2243() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2243");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9.4590893E8f, 699643.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.89321715E9f + "'", float2 == 1.89321715E9f);
    }

    @Test
    public void test2244() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2244");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(738.0f, 1.2625512E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.52511712E8f + "'", float2 == 2.52511712E8f);
    }

    @Test
    public void test2245() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2245");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 9621176.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.6211763E8f + "'", float2 == 9.6211763E8f);
    }

    @Test
    public void test2246() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2246");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9337572.0f, 109694.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.8894532E7f + "'", float2 == 1.8894532E7f);
    }

    @Test
    public void test2247() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2247");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-71822.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-451270.9351322522d) + "'", double1 == (-451270.9351322522d));
    }

    @Test
    public void test2248() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2248");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-10192.0f), 1.02393101E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.04784166E9f + "'", float2 == 2.04784166E9f);
    }

    @Test
    public void test2249() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2249");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(239224.0f, 1032.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 480512.0f + "'", float2 == 480512.0f);
    }

    @Test
    public void test2250() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2250");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1033946.0f, 1.189078E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.39883488E8f + "'", float2 == 2.39883488E8f);
    }

    @Test
    public void test2251() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2251");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1291048.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8111893.82446359d + "'", double1 == 8111893.82446359d);
    }

    @Test
    public void test2252() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2252");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1015.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6377.43308678728d) + "'", double1 == (-6377.43308678728d));
    }

    @Test
    public void test2253() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2253");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1853241.0f, (-7.4039562E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.48042056E10f) + "'", float2 == (-1.48042056E10f));
    }

    @Test
    public void test2254() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2254");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.8625022E7f, 887222.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.9024488E7f + "'", float2 == 5.9024488E7f);
    }

    @Test
    public void test2255() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2255");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-826550.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5193366.815649287d) + "'", double1 == (-5193366.815649287d));
    }

    @Test
    public void test2256() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2256");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(81687.0f, 74345.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 312064.0f + "'", float2 == 312064.0f);
    }

    @Test
    public void test2257() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2257");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 42832.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-42832.0f) + "'", float2 == (-42832.0f));
    }

    @Test
    public void test2258() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2258");
        double double1 = org.example.maths.Perimeter.perimeterCircle(344900.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2167070.612446239d + "'", double1 == 2167070.612446239d);
    }

    @Test
    public void test2259() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2259");
        double double1 = org.example.maths.Perimeter.perimeterCircle(6.2943984E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.9548871544414693E8d + "'", double1 == 3.9548871544414693E8d);
    }

    @Test
    public void test2260() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2260");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, 934.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 93400.0f + "'", float2 == 93400.0f);
    }

    @Test
    public void test2261() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2261");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-6.2719032E9f), (-3.6823511E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.99085097E10f) + "'", float2 == (-1.99085097E10f));
    }

    @Test
    public void test2262() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2262");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 716004.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 716004.0f + "'", float2 == 716004.0f);
    }

    @Test
    public void test2263() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2263");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.17568544E8f), (-8785422.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.527079E8f) + "'", float2 == (-6.527079E8f));
    }

    @Test
    public void test2264() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2264");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 2.04784166E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2265() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2265");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.15176704E9f), 1011926.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.3015101E9f) + "'", float2 == (-4.3015101E9f));
    }

    @Test
    public void test2266() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2266");
        float[] floatArray3 = null;
        // The following exception was thrown during execution in test generation
        try {
            float float4 = org.example.maths.Perimeter.perimeterIrregularPolygon(3.728902E7f, 0.0f, 1044754.0f, floatArray3);
            org.junit.Assert.fail("Expected exception of type java.lang.NullPointerException; message: null");
        } catch (java.lang.NullPointerException e) {
            // Expected exception.
        }
    }

    @Test
    public void test2267() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2267");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.5826E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.943769067142414E7d + "'", double1 == 9.943769067142414E7d);
    }

    @Test
    public void test2268() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2268");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2337508.0f), 6828036.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8981056.0f + "'", float2 == 8981056.0f);
    }

    @Test
    public void test2269() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2269");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 382172.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 382172.0f + "'", float2 == 382172.0f);
    }

    @Test
    public void test2270() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2270");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4025.0f), 666460.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1324870.0f + "'", float2 == 1324870.0f);
    }

    @Test
    public void test2271() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2271");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(161116.0f, (-4.92381312E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.8444038E8f) + "'", float2 == (-9.8444038E8f));
    }

    @Test
    public void test2272() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2272");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5100.0f, (-3.6826432E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.3652762E9f) + "'", float2 == (-7.3652762E9f));
    }

    @Test
    public void test2273() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2273");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-317440.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.1744E7f) + "'", float2 == (-3.1744E7f));
    }

    @Test
    public void test2274() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2274");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.79390624E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.1271445329625776E9d) + "'", double1 == (-1.1271445329625776E9d));
    }

    @Test
    public void test2275() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2275");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.348954E7f, 239224.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.7457528E7f + "'", float2 == 6.7457528E7f);
    }

    @Test
    public void test2276() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2276");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2332745.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.4657069109396644E7d + "'", double1 == 1.4657069109396644E7d);
    }

    @Test
    public void test2277() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2277");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 832768.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.6648576E7f + "'", float2 == 2.6648576E7f);
    }

    @Test
    public void test2278() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2278");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.8622046E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1700576581682238E8d + "'", double1 == 1.1700576581682238E8d);
    }

    @Test
    public void test2279() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2279");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4470.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 28085.83832309275d + "'", double1 == 28085.83832309275d);
    }

    @Test
    public void test2280() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2280");
        double double1 = org.example.maths.Perimeter.perimeterCircle(363808.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2285873.0802343907d + "'", double1 == 2285873.0802343907d);
    }

    @Test
    public void test2281() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2281");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.65622434E11f, 4.3962368E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.321241E11f + "'", float2 == 9.321241E11f);
    }

    @Test
    public void test2282() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2282");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.7560998E8f, 2780.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.35122547E9f + "'", float2 == 1.35122547E9f);
    }

    @Test
    public void test2283() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2283");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-88.0f), 961904.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1923632.0f + "'", float2 == 1923632.0f);
    }

    @Test
    public void test2284() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2284");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(70376.0f, 1195210.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2531172.0f + "'", float2 == 2531172.0f);
    }

    @Test
    public void test2285() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2285");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 212.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-212.0f) + "'", float2 == (-212.0f));
    }

    @Test
    public void test2286() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2286");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 607708.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1215416.0f + "'", float2 == 1215416.0f);
    }

    @Test
    public void test2287() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2287");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, (-3.8955896E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.89558976E8f) + "'", float2 == (-3.89558976E8f));
    }

    @Test
    public void test2288() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2288");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4627812.0f, (-57598.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9140428.0f + "'", float2 == 9140428.0f);
    }

    @Test
    public void test2289() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2289");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.5850459E7f, 2.8498382E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.869768E7f + "'", float2 == 8.869768E7f);
    }

    @Test
    public void test2290() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2290");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2305580.0f, (-4.50773888E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.9693664E8f) + "'", float2 == (-8.9693664E8f));
    }

    @Test
    public void test2291() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2291");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8374312.0f, 800846.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.8350316E7f + "'", float2 == 1.8350316E7f);
    }

    @Test
    public void test2292() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2292");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-8785422.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.5218592E8f) + "'", float2 == (-8.5218592E8f));
    }

    @Test
    public void test2293() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2293");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 3879620.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2294() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2294");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-40000.0f), 71591.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 63182.0f + "'", float2 == 63182.0f);
    }

    @Test
    public void test2295() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2295");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.05769133E9f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.11538266E9f + "'", float2 == 2.11538266E9f);
    }

    @Test
    public void test2296() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2296");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.924499E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.848998E7f + "'", float2 == 5.848998E7f);
    }

    @Test
    public void test2297() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2297");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 1.70635E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.70634995E9f + "'", float2 == 1.70634995E9f);
    }

    @Test
    public void test2298() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2298");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.1204544E8f), (-478555.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.25048E8f) + "'", float2 == (-6.25048E8f));
    }

    @Test
    public void test2299() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2299");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(233626.0f, (-2.3010176E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.59736256E8f) + "'", float2 == (-4.59736256E8f));
    }

    @Test
    public void test2300() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2300");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-520.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3267.2563597333847d) + "'", double1 == (-3267.2563597333847d));
    }

    @Test
    public void test2301() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2301");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.05040077E9f, 1210013.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.1032218E9f + "'", float2 == 6.1032218E9f);
    }

    @Test
    public void test2302() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2302");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 100255.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 200510.0f + "'", float2 == 200510.0f);
    }

    @Test
    public void test2303() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2303");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1338720.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8411425.834427455d + "'", double1 == 8411425.834427455d);
    }

    @Test
    public void test2304() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2304");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 0, 14497.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2305() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2305");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21340.0f, (-8.3582672E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.67122656E8f) + "'", float2 == (-1.67122656E8f));
    }

    @Test
    public void test2306() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2306");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1696240.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0657790245450301E7d + "'", double1 == 1.0657790245450301E7d);
    }

    @Test
    public void test2307() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2307");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1438.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9035.220471724246d + "'", double1 == 9035.220471724246d);
    }

    @Test
    public void test2308() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2308");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5464638.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.433533319065524E7d + "'", double1 == 3.433533319065524E7d);
    }

    @Test
    public void test2309() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2309");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(185344.0f, 1181606.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2733900.0f + "'", float2 == 2733900.0f);
    }

    @Test
    public void test2310() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2310");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7.4631448E7f, 1.94501408E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.3826573E8f + "'", float2 == 5.3826573E8f);
    }

    @Test
    public void test2311() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2311");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 1.94501408E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.94501408E8f) + "'", float2 == (-1.94501408E8f));
    }

    @Test
    public void test2312() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2312");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 2.8463926E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.9623744E8f + "'", float2 == 9.9623744E8f);
    }

    @Test
    public void test2313() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2313");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 3.27345178E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.27345178E9f + "'", float2 == 3.27345178E9f);
    }

    @Test
    public void test2314() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2314");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(367783.0f, (-3.0084864E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.0096173E8f) + "'", float2 == (-6.0096173E8f));
    }

    @Test
    public void test2315() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2315");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(961904.0f, 1856.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1927520.0f + "'", float2 == 1927520.0f);
    }

    @Test
    public void test2316() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2316");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.1120656E7f, 504.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2224232E8f + "'", float2 == 1.2224232E8f);
    }

    @Test
    public void test2317() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2317");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4.59736256E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.888608088876953E9d) + "'", double1 == (-2.888608088876953E9d));
    }

    @Test
    public void test2318() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2318");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 5039975.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2319() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2319");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1121818.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7048590.374929589d + "'", double1 == 7048590.374929589d);
    }

    @Test
    public void test2320() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2320");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-150868.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-301736.0f) + "'", float2 == (-301736.0f));
    }

    @Test
    public void test2321() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2321");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9.6211763E8f, (-985712.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.92226381E9f + "'", float2 == 1.92226381E9f);
    }

    @Test
    public void test2322() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2322");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.66773824E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.676189371296913E9d) + "'", double1 == (-1.676189371296913E9d));
    }

    @Test
    public void test2323() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2323");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 267534.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-267534.0f) + "'", float2 == (-267534.0f));
    }

    @Test
    public void test2324() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2324");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 2.8868614E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.50116787E9f + "'", float2 == 1.50116787E9f);
    }

    @Test
    public void test2325() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2325");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 1.1836307E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.14812173E9f + "'", float2 == 1.14812173E9f);
    }

    @Test
    public void test2326() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2326");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.11109248E8f), (-1.74262592E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.17074368E9f) + "'", float2 == (-1.17074368E9f));
    }

    @Test
    public void test2327() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2327");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.8650242E7f, (-1.40363904E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.43427328E8f) + "'", float2 == (-2.43427328E8f));
    }

    @Test
    public void test2328() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2328");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, 78.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 780.0f + "'", float2 == 780.0f);
    }

    @Test
    public void test2329() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2329");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-14402.0f), 2744.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-23316.0f) + "'", float2 == (-23316.0f));
    }

    @Test
    public void test2330() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2330");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.96956864E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8658350047509265E9d + "'", double1 == 1.8658350047509265E9d);
    }

    @Test
    public void test2331() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2331");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 188118.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-188118.0f) + "'", float2 == (-188118.0f));
    }

    @Test
    public void test2332() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2332");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3635851.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.2844725582294207E7d + "'", double1 == 2.2844725582294207E7d);
    }

    @Test
    public void test2333() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2333");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 6506.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2334() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2334");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(14556.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 29112.0f + "'", float2 == 29112.0f);
    }

    @Test
    public void test2335() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2335");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 1.70634995E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.70634995E9f + "'", float2 == 1.70634995E9f);
    }

    @Test
    public void test2336() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2336");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 6162800.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2337() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2337");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 77268.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7494996.0f + "'", float2 == 7494996.0f);
    }

    @Test
    public void test2338() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2338");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, (-1217.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-121700.0f) + "'", float2 == (-121700.0f));
    }

    @Test
    public void test2339() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2339");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4627812.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.9077400362789374E7d + "'", double1 == 2.9077400362789374E7d);
    }

    @Test
    public void test2340() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2340");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-6138418.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3.85688177869267E7d) + "'", double1 == (-3.85688177869267E7d));
    }

    @Test
    public void test2341() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2341");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-985712.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-6193411.155510604d) + "'", double1 == (-6193411.155510604d));
    }

    @Test
    public void test2342() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2342");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8900140.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.592122887984132E7d) + "'", double1 == (-5.592122887984132E7d));
    }

    @Test
    public void test2343() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2343");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.8790428E7f), 214310.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.7152236E7f) + "'", float2 == (-5.7152236E7f));
    }

    @Test
    public void test2344() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2344");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.02896064E9f, (-42980.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.05783526E9f + "'", float2 == 4.05783526E9f);
    }

    @Test
    public void test2345() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2345");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-472.0f), 815086.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1629228.0f + "'", float2 == 1629228.0f);
    }

    @Test
    public void test2346() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2346");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 6.7457528E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.745753E8f + "'", float2 == 6.745753E8f);
    }

    @Test
    public void test2347() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2347");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-8.0653056E8f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.61306112E9f) + "'", float2 == (-1.61306112E9f));
    }

    @Test
    public void test2348() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2348");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(21856.0f, (-890014.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1736316.0f) + "'", float2 == (-1736316.0f));
    }

    @Test
    public void test2349() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2349");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5671562.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.563547502715807E7d + "'", double1 == 3.563547502715807E7d);
    }

    @Test
    public void test2350() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2350");
        double double1 = org.example.maths.Perimeter.perimeterCircle(304611.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1913927.359605281d + "'", double1 == 1913927.359605281d);
    }

    @Test
    public void test2351() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2351");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2538165.0f, 4.4002208E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.3080744E7f + "'", float2 == 9.3080744E7f);
    }

    @Test
    public void test2352() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2352");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.2210262E7f, (-78860.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.4262804E7f + "'", float2 == 6.4262804E7f);
    }

    @Test
    public void test2353() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2353");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.5625624E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.2384239727590445E8d) + "'", double1 == (-2.2384239727590445E8d));
    }

    @Test
    public void test2354() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2354");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 3.92861696E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.928617E10f + "'", float2 == 3.928617E10f);
    }

    @Test
    public void test2355() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2355");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.01037632E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.8914752262905352E9d) + "'", double1 == (-1.8914752262905352E9d));
    }

    @Test
    public void test2356() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2356");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9076.0f, (-260.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 17632.0f + "'", float2 == 17632.0f);
    }

    @Test
    public void test2357() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2357");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(155107.0f, 3.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 310220.0f + "'", float2 == 310220.0f);
    }

    @Test
    public void test2358() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2358");
        double double1 = org.example.maths.Perimeter.perimeterCircle(444987.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2795935.7802859223d + "'", double1 == 2795935.7802859223d);
    }

    @Test
    public void test2359() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2359");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(888311.0f, 1.2932322E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.7641266E7f + "'", float2 == 2.7641266E7f);
    }

    @Test
    public void test2360() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2360");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7229144.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4458288E7f + "'", float2 == 1.4458288E7f);
    }

    @Test
    public void test2361() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2361");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.05783526E9f, 4.4364392E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.2043991E9f + "'", float2 == 8.2043991E9f);
    }

    @Test
    public void test2362() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2362");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.0283E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.2744184758552355E8d) + "'", double1 == (-1.2744184758552355E8d));
    }

    @Test
    public void test2363() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2363");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-58800.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-369451.29606215964d) + "'", double1 == (-369451.29606215964d));
    }

    @Test
    public void test2364() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2364");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-1888.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-18880.0f) + "'", float2 == (-18880.0f));
    }

    @Test
    public void test2365() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2365");
        double double1 = org.example.maths.Perimeter.perimeterCircle(105821.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 664892.952391051d + "'", double1 == 664892.952391051d);
    }

    @Test
    public void test2366() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2366");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, (-35188.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-35188.0f) + "'", float2 == (-35188.0f));
    }

    @Test
    public void test2367() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2367");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, 13032.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-13032.0f) + "'", float2 == (-13032.0f));
    }

    @Test
    public void test2368() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2368");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 3303707.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.15629744E8f + "'", float2 == 1.15629744E8f);
    }

    @Test
    public void test2369() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2369");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.0199592E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6.408592659362645E7d + "'", double1 == 6.408592659362645E7d);
    }

    @Test
    public void test2370() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2370");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 1.48564608E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2371() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2371");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.8350316E7f, 3040640.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.2781912E7f + "'", float2 == 4.2781912E7f);
    }

    @Test
    public void test2372() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2372");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-52.0f), (-2.58767766E11f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.17535531E11f) + "'", float2 == (-5.17535531E11f));
    }

    @Test
    public void test2373() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2373");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 3008447.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.008447E7f + "'", float2 == 3.008447E7f);
    }

    @Test
    public void test2374() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2374");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3976150.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.4982887259142112E7d) + "'", double1 == (-2.4982887259142112E7d));
    }

    @Test
    public void test2375() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2375");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-370254.0f), (-1885268.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4511044.0f) + "'", float2 == (-4511044.0f));
    }

    @Test
    public void test2376() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2376");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-115.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-722.5663103256525d) + "'", double1 == (-722.5663103256525d));
    }

    @Test
    public void test2377() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2377");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.78664016E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1225791202528985E9d + "'", double1 == 1.1225791202528985E9d);
    }

    @Test
    public void test2378() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2378");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(151168.0f, 795642.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1893620.0f + "'", float2 == 1893620.0f);
    }

    @Test
    public void test2379() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2379");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.6648576E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6743794118045855E8d + "'", double1 == 1.6743794118045855E8d);
    }

    @Test
    public void test2380() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2380");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(178809.0f, 524540.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1406698.0f + "'", float2 == 1406698.0f);
    }

    @Test
    public void test2381() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2381");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-43713.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-274656.87933274126d) + "'", double1 == (-274656.87933274126d));
    }

    @Test
    public void test2382() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2382");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-24370.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-153121.2259359665d) + "'", double1 == (-153121.2259359665d));
    }

    @Test
    public void test2383() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2383");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.4955444E7f, 3.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.9910894E7f + "'", float2 == 2.9910894E7f);
    }

    @Test
    public void test2384() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2384");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.05329638E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.918442697841336E10d + "'", double1 == 1.918442697841336E10d);
    }

    @Test
    public void test2385() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2385");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((float) 1L, 5815188.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1630378E7f + "'", float2 == 1.1630378E7f);
    }

    @Test
    public void test2386() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2386");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.65877952E8f, (float) (byte) 1);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.31755904E8f + "'", float2 == 3.31755904E8f);
    }

    @Test
    public void test2387() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2387");
        double double1 = org.example.maths.Perimeter.perimeterCircle(9.1497024E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.74892756847458E8d + "'", double1 == 5.74892756847458E8d);
    }

    @Test
    public void test2388() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2388");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 3.1019542E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.10195424E8f + "'", float2 == 3.10195424E8f);
    }

    @Test
    public void test2389() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2389");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(124936.0f, (-6696711.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.314355E7f) + "'", float2 == (-1.314355E7f));
    }

    @Test
    public void test2390() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2390");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.729804E7f, 336223.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.5268528E7f + "'", float2 == 7.5268528E7f);
    }

    @Test
    public void test2391() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2391");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-1.06395432E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.0639543E9f) + "'", float2 == (-1.0639543E9f));
    }

    @Test
    public void test2392() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2392");
        double double1 = org.example.maths.Perimeter.perimeterCircle(7185585.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 4.514836209549002E7d + "'", double1 == 4.514836209549002E7d);
    }

    @Test
    public void test2393() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2393");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2871398.0f, 1812400.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9367596.0f + "'", float2 == 9367596.0f);
    }

    @Test
    public void test2394() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2394");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 9.9250768E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1610399E9f + "'", float2 == 5.1610399E9f);
    }

    @Test
    public void test2395() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2395");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 18124.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2396() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2396");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.56780224E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.2417162613290415E9d + "'", double1 == 2.2417162613290415E9d);
    }

    @Test
    public void test2397() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2397");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(505416.0f, 1.8621926E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.8254684E7f + "'", float2 == 3.8254684E7f);
    }

    @Test
    public void test2398() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2398");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1.02574592E9f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.05149184E9f + "'", float2 == 2.05149184E9f);
    }

    @Test
    public void test2399() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2399");
        double double1 = org.example.maths.Perimeter.perimeterCircle(506172.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3180372.4733057055d + "'", double1 == 3180372.4733057055d);
    }

    @Test
    public void test2400() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2400");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(233943.0f, 4572.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 477030.0f + "'", float2 == 477030.0f);
    }

    @Test
    public void test2401() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2401");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-3823352.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3823352.0f + "'", float2 == 3823352.0f);
    }

    @Test
    public void test2402() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2402");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.69052736E8f), 1.0190123E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.1772525E8f) + "'", float2 == (-9.1772525E8f));
    }

    @Test
    public void test2403() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2403");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.5686676E7f, 2.895672E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.3050778E8f + "'", float2 == 6.3050778E8f);
    }

    @Test
    public void test2404() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2404");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(231280.0f, (-1150753.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1838946.0f) + "'", float2 == (-1838946.0f));
    }

    @Test
    public void test2405() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2405");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, 1.28386E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2406() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2406");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.6826432E9f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.3138729645824814E10d) + "'", double1 == (-2.3138729645824814E10d));
    }

    @Test
    public void test2407() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2407");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.150826E8f), 2623704.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.24917792E8f) + "'", float2 == (-2.24917792E8f));
    }

    @Test
    public void test2408() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2408");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 9140428.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.19914976E8f + "'", float2 == 3.19914976E8f);
    }

    @Test
    public void test2409() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2409");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3348107.0f), (-1015.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6698244.0f) + "'", float2 == (-6698244.0f));
    }

    @Test
    public void test2410() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2410");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1044754.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 6564382.982417101d + "'", double1 == 6564382.982417101d);
    }

    @Test
    public void test2411() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2411");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(13012.0f, 292252.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 610528.0f + "'", float2 == 610528.0f);
    }

    @Test
    public void test2412() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2412");
        double double1 = org.example.maths.Perimeter.perimeterCircle(29188.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 183393.61274595777d + "'", double1 == 183393.61274595777d);
    }

    @Test
    public void test2413() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2413");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.6826432E9f), 2.96956864E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.7713725E9f) + "'", float2 == (-6.7713725E9f));
    }

    @Test
    public void test2414() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2414");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.0934852E7f, 6.8754323E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.43695616E9f + "'", float2 == 1.43695616E9f);
    }

    @Test
    public void test2415() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2415");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 2.534976E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.534976E8f + "'", float2 == 2.534976E8f);
    }

    @Test
    public void test2416() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2416");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.375624E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.4926485812183198E8d + "'", double1 == 1.4926485812183198E8d);
    }

    @Test
    public void test2417() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2417");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5573438.0f, (-1.565469E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.0162504E7f) + "'", float2 == (-2.0162504E7f));
    }

    @Test
    public void test2418() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2418");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-8.2083981E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-5.157488621173713E9d) + "'", double1 == (-5.157488621173713E9d));
    }

    @Test
    public void test2419() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2419");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3087539.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.9399579680143952E7d + "'", double1 == 1.9399579680143952E7d);
    }

    @Test
    public void test2420() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2420");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-3.4852073E9f), 3.50545152E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.2693243E9f) + "'", float2 == (-6.2693243E9f));
    }

    @Test
    public void test2421() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2421");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-4274600.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.2746E7f) + "'", float2 == (-4.2746E7f));
    }

    @Test
    public void test2422() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2422");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-4200.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-26389.37829015426d) + "'", double1 == (-26389.37829015426d));
    }

    @Test
    public void test2423() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2423");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 977779.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 977779.0f + "'", float2 == 977779.0f);
    }

    @Test
    public void test2424() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2424");
        double double1 = org.example.maths.Perimeter.perimeterCircle(424.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2664.0705702441446d + "'", double1 == 2664.0705702441446d);
    }

    @Test
    public void test2425() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2425");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-317440.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1994534.3439110878d) + "'", double1 == (-1994534.3439110878d));
    }

    @Test
    public void test2426() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2426");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.7567334E8f, 1.6245677E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.38383808E9f + "'", float2 == 1.38383808E9f);
    }

    @Test
    public void test2427() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2427");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 4496007.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.43872224E8f + "'", float2 == 1.43872224E8f);
    }

    @Test
    public void test2428() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2428");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 266168.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2661680.0f + "'", float2 == 2661680.0f);
    }

    @Test
    public void test2429() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2429");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.081372E7f, 9310.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.21646064E8f + "'", float2 == 1.21646064E8f);
    }

    @Test
    public void test2430() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2430");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9981160.0f, (-6.2693524E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.2518743E10f) + "'", float2 == (-1.2518743E10f));
    }

    @Test
    public void test2431() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2431");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1944082.0f, 1.27948472E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.59785104E8f + "'", float2 == 2.59785104E8f);
    }

    @Test
    public void test2432() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2432");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.40414336E8f, 175744.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.8118016E8f + "'", float2 == 8.8118016E8f);
    }

    @Test
    public void test2433() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2433");
        double double1 = org.example.maths.Perimeter.perimeterCircle(173269.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1088681.2349896997d + "'", double1 == 1088681.2349896997d);
    }

    @Test
    public void test2434() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2434");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.372148E8f), (-3.8955896E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.5234138E8f) + "'", float2 == (-5.5234138E8f));
    }

    @Test
    public void test2435() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2435");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(958511.0f, 4462487.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.0841996E7f + "'", float2 == 1.0841996E7f);
    }

    @Test
    public void test2436() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2436");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-5.9054736E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-3.7105184955456936E8d) + "'", double1 == (-3.7105184955456936E8d));
    }

    @Test
    public void test2437() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2437");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4.6693519E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.9338403478325756E10d + "'", double1 == 2.9338403478325756E10d);
    }

    @Test
    public void test2438() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2438");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, 1.01394512E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.02789024E8f + "'", float2 == 2.02789024E8f);
    }

    @Test
    public void test2439() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2439");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 1.19684432E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.18895514E9f + "'", float2 == 4.18895514E9f);
    }

    @Test
    public void test2440() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2440");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4.672052E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.9355368480779E8d + "'", double1 == 2.9355368480779E8d);
    }

    @Test
    public void test2441() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2441");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', (-112.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-10864.0f) + "'", float2 == (-10864.0f));
    }

    @Test
    public void test2442() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2442");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.4055352E7f, 1.12514072E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.53138848E8f + "'", float2 == 3.53138848E8f);
    }

    @Test
    public void test2443() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2443");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.49600704E8f, 2.96956864E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.49311514E9f + "'", float2 == 1.49311514E9f);
    }

    @Test
    public void test2444() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2444");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4549446.0f, 1702207.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.2503306E7f + "'", float2 == 1.2503306E7f);
    }

    @Test
    public void test2445() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2445");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1168736.0f, 2000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2341472.0f + "'", float2 == 2341472.0f);
    }

    @Test
    public void test2446() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2446");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.563036E7f), 3926864.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.3406992E7f) + "'", float2 == (-2.3406992E7f));
    }

    @Test
    public void test2447() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2447");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.7501904E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0996770606046763E8d + "'", double1 == 1.0996770606046763E8d);
    }

    @Test
    public void test2448() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2448");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2681740.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.6849869365675785E7d + "'", double1 == 1.6849869365675785E7d);
    }

    @Test
    public void test2449() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2449");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(17632.0f, 1718.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 38700.0f + "'", float2 == 38700.0f);
    }

    @Test
    public void test2450() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2450");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-7.187063E8f), 100255.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.43721216E9f) + "'", float2 == (-1.43721216E9f));
    }

    @Test
    public void test2451() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2451");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 2.13652E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2.13652E8f) + "'", float2 == (-2.13652E8f));
    }

    @Test
    public void test2452() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2452");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.1637994E7f, 4.65796268E11f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.316158E11f + "'", float2 == 9.316158E11f);
    }

    @Test
    public void test2453() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2453");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(214310.0f, 1243920.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2916460.0f + "'", float2 == 2916460.0f);
    }

    @Test
    public void test2454() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2454");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5.848998E7f, 5387.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.16990736E8f + "'", float2 == 1.16990736E8f);
    }

    @Test
    public void test2455() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2455");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1.43872224E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.4387223E9f + "'", float2 == 1.4387223E9f);
    }

    @Test
    public void test2456() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2456");
        double double1 = org.example.maths.Perimeter.perimeterCircle(5.5633645E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.49556499592208E9d + "'", double1 == 3.49556499592208E9d);
    }

    @Test
    public void test2457() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2457");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8309408.0f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.6618816E7f + "'", float2 == 1.6618816E7f);
    }

    @Test
    public void test2458() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2458");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.27345178E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.056770410272412E10d + "'", double1 == 2.056770410272412E10d);
    }

    @Test
    public void test2459() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2459");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(117.0f, 3.8234312E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7.6468856E7f + "'", float2 == 7.6468856E7f);
    }

    @Test
    public void test2460() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2460");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.19684432E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.519994646405343E8d + "'", double1 == 7.519994646405343E8d);
    }

    @Test
    public void test2461() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2461");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-9712280.0f), (-2.02999824E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.25424192E8f) + "'", float2 == (-4.25424192E8f));
    }

    @Test
    public void test2462() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2462");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(5359.0f, 20198.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 51114.0f + "'", float2 == 51114.0f);
    }

    @Test
    public void test2463() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2463");
        double double1 = org.example.maths.Perimeter.perimeterCircle(182592.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1147259.371608535d + "'", double1 == 1147259.371608535d);
    }

    @Test
    public void test2464() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2464");
        double double1 = org.example.maths.Perimeter.perimeterCircle(267294.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1679457.7334972604d + "'", double1 == 1679457.7334972604d);
    }

    @Test
    public void test2465() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2465");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.4411372E7f, 1122385.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.1067514E7f + "'", float2 == 3.1067514E7f);
    }

    @Test
    public void test2466() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2466");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '#', 2.56083424E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.9629194E9f + "'", float2 == 8.9629194E9f);
    }

    @Test
    public void test2467() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2467");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(8091100.0f, 5.0870592E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.17923384E8f + "'", float2 == 1.17923384E8f);
    }

    @Test
    public void test2468() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2468");
        double double1 = org.example.maths.Perimeter.perimeterCircle(444826.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2794924.1874514665d + "'", double1 == 2794924.1874514665d);
    }

    @Test
    public void test2469() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2469");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 1, 1425140.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1425140.0f + "'", float2 == 1425140.0f);
    }

    @Test
    public void test2470() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2470");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 2136520.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.13652E7f + "'", float2 == 2.13652E7f);
    }

    @Test
    public void test2471() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2471");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-156326.0f), 3879620.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 7446588.0f + "'", float2 == 7446588.0f);
    }

    @Test
    public void test2472() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2472");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7783474.0f, (-42980.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.5480988E7f + "'", float2 == 1.5480988E7f);
    }

    @Test
    public void test2473() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2473");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2056880.0f), 8863120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.361248E7f + "'", float2 == 1.361248E7f);
    }

    @Test
    public void test2474() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2474");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(798.0f, (-39416.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-77236.0f) + "'", float2 == (-77236.0f));
    }

    @Test
    public void test2475() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2475");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-9180052.0f), 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.8360104E7f) + "'", float2 == (-1.8360104E7f));
    }

    @Test
    public void test2476() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2476");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(135.0f, (-6.25048E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1.25009574E9f) + "'", float2 == (-1.25009574E9f));
    }

    @Test
    public void test2477() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2477");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 1696240.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1696240.0f) + "'", float2 == (-1696240.0f));
    }

    @Test
    public void test2478() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2478");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2970944.0f, (-241500.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5458888.0f + "'", float2 == 5458888.0f);
    }

    @Test
    public void test2479() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2479");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 0, (-212.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-0.0f) + "'", float2 == (-0.0f));
    }

    @Test
    public void test2480() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2480");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(10, (-6900.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-69000.0f) + "'", float2 == (-69000.0f));
    }

    @Test
    public void test2481() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2481");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 2.0637626E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.0637626E7f + "'", float2 == 2.0637626E7f);
    }

    @Test
    public void test2482() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2482");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 8.6086963E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.6086963E8f) + "'", float2 == (-8.6086963E8f));
    }

    @Test
    public void test2483() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2483");
        double double1 = org.example.maths.Perimeter.perimeterCircle(316192.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1986692.9286477277d + "'", double1 == 1986692.9286477277d);
    }

    @Test
    public void test2484() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2484");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2370.0f), 884.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-2972.0f) + "'", float2 == (-2972.0f));
    }

    @Test
    public void test2485() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2485");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1846426.0f, 9140428.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.1973708E7f + "'", float2 == 2.1973708E7f);
    }

    @Test
    public void test2486() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2486");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-10192.0f), 86064.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 151744.0f + "'", float2 == 151744.0f);
    }

    @Test
    public void test2487() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2487");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.05293424E8f), 1.5993138E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.78600576E8f) + "'", float2 == (-3.78600576E8f));
    }

    @Test
    public void test2488() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2488");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-2.0162504E7f), 1.2669796E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.13070912E8f + "'", float2 == 2.13070912E8f);
    }

    @Test
    public void test2489() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2489");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5626.0f), 1.1395412E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.2779572E7f + "'", float2 == 2.2779572E7f);
    }

    @Test
    public void test2490() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2490");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.28841648E8f, 131880.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.57947072E8f + "'", float2 == 4.57947072E8f);
    }

    @Test
    public void test2491() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2491");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.2497728E7f, 41476.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.5078408E7f + "'", float2 == 2.5078408E7f);
    }

    @Test
    public void test2492() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2492");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2341472.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.47119024675724E7d + "'", double1 == 1.47119024675724E7d);
    }

    @Test
    public void test2493() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2493");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 79130.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2494() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2494");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, (-26820.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-268200.0f) + "'", float2 == (-268200.0f));
    }

    @Test
    public void test2495() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2495");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 486110.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2496() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2496");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1624623.0f), (-2.15176704E9f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.3067832E9f) + "'", float2 == (-4.3067832E9f));
    }

    @Test
    public void test2497() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2497");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.35353568E8f, 7.377856E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6.1826426E8f + "'", float2 == 6.1826426E8f);
    }

    @Test
    public void test2498() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2498");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, (-481312.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-4.81312E7f) + "'", float2 == (-4.81312E7f));
    }

    @Test
    public void test2499() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2499");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 100, 5.11965376E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1196539E10f + "'", float2 == 5.1196539E10f);
    }

    @Test
    public void test2500() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2500");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.64372173E9f), 88576.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-3.2872663E9f) + "'", float2 == (-3.2872663E9f));
    }

    @Test
    public void test2501() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2501");
        double double1 = org.example.maths.Perimeter.perimeterCircle(175120.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1100311.4109932892d + "'", double1 == 1100311.4109932892d);
    }

    @Test
    public void test2502() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2502");
        double double1 = org.example.maths.Perimeter.perimeterCircle(3.02690848E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.9018626887713294E9d + "'", double1 == 1.9018626887713294E9d);
    }

    @Test
    public void test2503() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2503");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 1211209.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-1211209.0f) + "'", float2 == (-1211209.0f));
    }

    @Test
    public void test2504() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2504");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(3.0f, 1.1139796E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.2279598E7f + "'", float2 == 2.2279598E7f);
    }

    @Test
    public void test2505() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2505");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(86076.0f, 1955579.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4083310.0f + "'", float2 == 4083310.0f);
    }

    @Test
    public void test2506() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2506");
        double double1 = org.example.maths.Perimeter.perimeterCircle(153353.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 963545.316411911d + "'", double1 == 963545.316411911d);
    }

    @Test
    public void test2507() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2507");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 20198.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2508() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2508");
        double double1 = org.example.maths.Perimeter.perimeterCircle(832768.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5232435.66188933d + "'", double1 == 5232435.66188933d);
    }

    @Test
    public void test2509() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2509");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9214.0f, 1.39854784E8f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.79728E8f + "'", float2 == 2.79728E8f);
    }

    @Test
    public void test2510() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2510");
        double double1 = org.example.maths.Perimeter.perimeterCircle(126602.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 795463.8262595499d + "'", double1 == 795463.8262595499d);
    }

    @Test
    public void test2511() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2511");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.294496E7f, 2.2279598E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.7044912E8f + "'", float2 == 1.7044912E8f);
    }

    @Test
    public void test2512() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2512");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) -1, 406335.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-406335.0f) + "'", float2 == (-406335.0f));
    }

    @Test
    public void test2513() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2513");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-962240.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 962240.0f + "'", float2 == 962240.0f);
    }

    @Test
    public void test2514() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2514");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(4.391658E7f, 22052.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 8.7877264E7f + "'", float2 == 8.7877264E7f);
    }

    @Test
    public void test2515() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2515");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.5686676E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.613941452334825E8d + "'", double1 == 1.613941452334825E8d);
    }

    @Test
    public void test2516() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2516");
        double double1 = org.example.maths.Perimeter.perimeterCircle(2.93271117E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.8426767720979084E10d + "'", double1 == 1.8426767720979084E10d);
    }

    @Test
    public void test2517() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2517");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 10, 5.1432472E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.14324736E8f + "'", float2 == 5.14324736E8f);
    }

    @Test
    public void test2518() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2518");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 1.82456975E10f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.82456975E10f + "'", float2 == 1.82456975E10f);
    }

    @Test
    public void test2519() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2519");
        double double1 = org.example.maths.Perimeter.perimeterCircle(117.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 735.1326809400116d + "'", double1 == 735.1326809400116d);
    }

    @Test
    public void test2520() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2520");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4023412.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 2.5279843163130034E7d + "'", double1 == 2.5279843163130034E7d);
    }

    @Test
    public void test2521() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2521");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.804123E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.1335639125944756E8d + "'", double1 == 1.1335639125944756E8d);
    }

    @Test
    public void test2522() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2522");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2.00474E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.2596152912715204E8d) + "'", double1 == (-1.2596152912715204E8d));
    }

    @Test
    public void test2523() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2523");
        double double1 = org.example.maths.Perimeter.perimeterCircle(570.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3581.4156250923643d + "'", double1 == 3581.4156250923643d);
    }

    @Test
    public void test2524() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2524");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-1.14713128E8f), (-1.73796784E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.7701984E8f) + "'", float2 == (-5.7701984E8f));
    }

    @Test
    public void test2525() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2525");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) 'a', 503920.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 4.888024E7f + "'", float2 == 4.888024E7f);
    }

    @Test
    public void test2526() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2526");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1406698.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8838544.20523891d + "'", double1 == 8838544.20523891d);
    }

    @Test
    public void test2527() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2527");
        double double1 = org.example.maths.Perimeter.perimeterCircle(39279.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 246797.23568070697d + "'", double1 == 246797.23568070697d);
    }

    @Test
    public void test2528() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2528");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4560.0f), 1456.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6208.0f) + "'", float2 == (-6208.0f));
    }

    @Test
    public void test2529() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2529");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-3.8955896E7f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2.44767113375216E8d) + "'", double1 == (-2.44767113375216E8d));
    }

    @Test
    public void test2530() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2530");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.8466122E7f, (-384348.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.6163548E7f + "'", float2 == 3.6163548E7f);
    }

    @Test
    public void test2531() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2531");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-4.11109248E8f), (-8390271.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-8.3899904E8f) + "'", float2 == (-8.3899904E8f));
    }

    @Test
    public void test2532() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2532");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.7000652E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.0681824685887325E8d + "'", double1 == 1.0681824685887325E8d);
    }

    @Test
    public void test2533() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2533");
        double double1 = org.example.maths.Perimeter.perimeterCircle(291880.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1833936.1274595775d + "'", double1 == 1833936.1274595775d);
    }

    @Test
    public void test2534() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2534");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-4.67379392E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-9.3475878E8f) + "'", float2 == (-9.3475878E8f));
    }

    @Test
    public void test2535() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2535");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) -1, (-1264480.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1264480.0f + "'", float2 == 1264480.0f);
    }

    @Test
    public void test2536() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2536");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(100, (-712493.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.1249296E7f) + "'", float2 == (-7.1249296E7f));
    }

    @Test
    public void test2537() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2537");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 231280.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 231280.0f + "'", float2 == 231280.0f);
    }

    @Test
    public void test2538() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2538");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5387.0f), 212259.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 413744.0f + "'", float2 == 413744.0f);
    }

    @Test
    public void test2539() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2539");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.26698008E8f, 439021.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.54274064E8f + "'", float2 == 2.54274064E8f);
    }

    @Test
    public void test2540() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2540");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2.090025E7f, (-4018512.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.3763476E7f + "'", float2 == 3.3763476E7f);
    }

    @Test
    public void test2541() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2541");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6068720.0f, (-2.58767766E11f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.17523407E11f) + "'", float2 == (-5.17523407E11f));
    }

    @Test
    public void test2542() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2542");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(0.0f, (-200474.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-400948.0f) + "'", float2 == (-400948.0f));
    }

    @Test
    public void test2543() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2543");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(0, 109694.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 0.0f + "'", float2 == 0.0f);
    }

    @Test
    public void test2544() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2544");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.19638912E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.517134540453515E9d + "'", double1 == 7.517134540453515E9d);
    }

    @Test
    public void test2545() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2545");
        double double1 = org.example.maths.Perimeter.perimeterCircle(4922194.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3.0927057019887514E7d + "'", double1 == 3.0927057019887514E7d);
    }

    @Test
    public void test2546() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2546");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 10, 1032.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 10320.0f + "'", float2 == 10320.0f);
    }

    @Test
    public void test2547() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2547");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 5.1432472E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5.1432474E9f + "'", float2 == 5.1432474E9f);
    }

    @Test
    public void test2548() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2548");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 2882247.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 9.2231904E7f + "'", float2 == 9.2231904E7f);
    }

    @Test
    public void test2549() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2549");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 3699172.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.92356944E8f + "'", float2 == 1.92356944E8f);
    }

    @Test
    public void test2550() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2550");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(40.0f, 2880875.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 5761830.0f + "'", float2 == 5761830.0f);
    }

    @Test
    public void test2551() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2551");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(30670.0f, (-2.8570706E7f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-5.7080072E7f) + "'", float2 == (-5.7080072E7f));
    }

    @Test
    public void test2552() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2552");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 3.8254684E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3.82546842E9f + "'", float2 == 3.82546842E9f);
    }

    @Test
    public void test2553() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2553");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon(1, 3665608.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 3665608.0f + "'", float2 == 3665608.0f);
    }

    @Test
    public void test2554() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2554");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((-1), 6.2887808E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-6.2887808E7f) + "'", float2 == (-6.2887808E7f));
    }

    @Test
    public void test2555() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2555");
        double double1 = org.example.maths.Perimeter.perimeterCircle(29112.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 182916.0906626121d + "'", double1 == 182916.0906626121d);
    }

    @Test
    public void test2556() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2556");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (byte) 1, 667045.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 667045.0f + "'", float2 == 667045.0f);
    }

    @Test
    public void test2557() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2557");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.19808E9f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 7.527758652825719E9d + "'", double1 == 7.527758652825719E9d);
    }

    @Test
    public void test2558() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2558");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(9120327.0f, (-38515.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.8163624E7f + "'", float2 == 1.8163624E7f);
    }

    @Test
    public void test2559() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2559");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.4741247E7f, 0.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.9482494E7f + "'", float2 == 2.9482494E7f);
    }

    @Test
    public void test2560() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2560");
        double double1 = org.example.maths.Perimeter.perimeterCircle(278000.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1746725.515395925d + "'", double1 == 1746725.515395925d);
    }

    @Test
    public void test2561() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2561");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) '4', 8120.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 422240.0f + "'", float2 == 422240.0f);
    }

    @Test
    public void test2562() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2562");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.28999976E8f, (-36941.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.57926064E8f + "'", float2 == 2.57926064E8f);
    }

    @Test
    public void test2563() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2563");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7848400.0f, 17000.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.57308E7f + "'", float2 == 1.57308E7f);
    }

    @Test
    public void test2564() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2564");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1.0150716E7f, 1121818.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.2545068E7f + "'", float2 == 2.2545068E7f);
    }

    @Test
    public void test2565() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2565");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 6402.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 204864.0f + "'", float2 == 204864.0f);
    }

    @Test
    public void test2566() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2566");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) (short) 100, 68190.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6819000.0f + "'", float2 == 6819000.0f);
    }

    @Test
    public void test2567() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2567");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.31417864E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 8.257227921857251E8d + "'", double1 == 8.257227921857251E8d);
    }

    @Test
    public void test2568() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2568");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1.4995036E7f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 9.421658987582895E7d + "'", double1 == 9.421658987582895E7d);
    }

    @Test
    public void test2569() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2569");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(7935393.0f, 5671562.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.721391E7f + "'", float2 == 2.721391E7f);
    }

    @Test
    public void test2570() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2570");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-5917282.0f), (-3.84512128E8f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + (-7.8085882E8f) + "'", float2 == (-7.8085882E8f));
    }

    @Test
    public void test2571() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2571");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-1.79664768E8f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-1.128867030515429E9d) + "'", double1 == (-1.128867030515429E9d));
    }

    @Test
    public void test2572() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2572");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(1861290.0f, 1195210.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 6113000.0f + "'", float2 == 6113000.0f);
    }

    @Test
    public void test2573() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2573");
        double double1 = org.example.maths.Perimeter.perimeterCircle(8.1285613E8f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 5.107325680300489E9d + "'", double1 == 5.107325680300489E9d);
    }

    @Test
    public void test2574() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2574");
        float float2 = org.example.maths.Perimeter.perimeterRectangle((-43628.0f), 1.4826633E7f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.956601E7f + "'", float2 == 2.956601E7f);
    }

    @Test
    public void test2575() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2575");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(6.1032218E9f, (-175744.0f));
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.22060923E10f + "'", float2 == 1.22060923E10f);
    }

    @Test
    public void test2576() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2576");
        double double1 = org.example.maths.Perimeter.perimeterCircle(1939800.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1.2188122858866962E7d + "'", double1 == 1.2188122858866962E7d);
    }

    @Test
    public void test2577() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2577");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-2370.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-14891.14917801562d) + "'", double1 == (-14891.14917801562d));
    }

    @Test
    public void test2578() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2578");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-363742.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-2285458.390004117d) + "'", double1 == (-2285458.390004117d));
    }

    @Test
    public void test2579() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2579");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(233626.0f, 709905.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1887062.0f + "'", float2 == 1887062.0f);
    }

    @Test
    public void test2580() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2580");
        double double1 = org.example.maths.Perimeter.perimeterCircle(231280.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 1453175.0978444947d + "'", double1 == 1453175.0978444947d);
    }

    @Test
    public void test2581() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2581");
        double double1 = org.example.maths.Perimeter.perimeterCircle(597605.0f);
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + 3754862.9554970567d + "'", double1 == 3754862.9554970567d);
    }

    @Test
    public void test2582() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2582");
        double double1 = org.example.maths.Perimeter.perimeterCircle((-74904.0f));
        org.junit.Assert.assertTrue("'" + double1 + "' != '" + (-470635.7122489797d) + "'", double1 == (-470635.7122489797d));
    }

    @Test
    public void test2583() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2583");
        float float2 = org.example.maths.Perimeter.perimeterRegularPolygon((int) ' ', 8334915.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 2.6671728E8f + "'", float2 == 2.6671728E8f);
    }

    @Test
    public void test2584() throws Throwable {
        if (debug)
            System.out.format("%n%s%n", "PerimeterRegressionTest0.test2584");
        float float2 = org.example.maths.Perimeter.perimeterRectangle(2922098.0f, 2867216.0f);
        org.junit.Assert.assertTrue("'" + float2 + "' != '" + 1.1578628E7f + "'", float2 == 1.1578628E7f);
    }
}

